test=develop (#2127)

doc/fluid/api_cn/backward_cn/append_backward_cn.rst

@@ -3,10 +3,13 @@
 append_backward
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.backward.append_backward(loss, parameter_list=None, no_grad_set=None, callbacks=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口将向主程序（``main_program``）追加反向部分 。
 
 完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。

doc/fluid/api_cn/backward_cn/gradients_cn.rst

@@ -3,10 +3,13 @@
 gradients
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.backward.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 将目标梯度反向传播到输入。
 
 参数：  

doc/fluid/api_cn/clip_cn/ErrorClipByValue_cn.rst

@@ -5,6 +5,9 @@ ErrorClipByValue
 
 .. py:class:: paddle.fluid.clip.ErrorClipByValue(max, min=None)
 
+
+
+
 给定一个 Tensor  ``t`` （该 Tensor 传入方式见代码示例），对 Tensor 中的元素超出给定最大 ``max`` 和最小界 ``min`` 内区间范围 [min, max] 的元素，重设为所超出界的界值。
 
 

doc/fluid/api_cn/clip_cn/GradientClipByGlobalNorm_cn.rst

@@ -5,6 +5,12 @@ GradientClipByGlobalNorm
 
 .. py:class:: paddle.fluid.clip.GradientClipByGlobalNorm(clip_norm, group_name='default_group', need_clip=None)
 
+:alias_main: paddle.nn.GradientClipByGlobalNorm
+:alias: paddle.nn.GradientClipByGlobalNorm,paddle.nn.clip.GradientClipByGlobalNorm
+:old_api: paddle.fluid.clip.GradientClipByGlobalNorm
+
+
+ 
 将一个 Tensor列表 :math:`t\_list` 中所有Tensor的L2范数之和，限定在 ``clip_norm`` 范围内。
 
 - 如果范数之和大于 ``clip_norm`` ，则所有 Tensor 会乘以一个系数进行压缩

doc/fluid/api_cn/clip_cn/GradientClipByNorm_cn.rst

@@ -5,6 +5,12 @@ GradientClipByNorm
 
 .. py:class:: paddle.fluid.clip.GradientClipByNorm(clip_norm, need_clip=None)
 
+:alias_main: paddle.nn.GradientClipByNorm
+:alias: paddle.nn.GradientClipByNorm,paddle.nn.clip.GradientClipByNorm
+:old_api: paddle.fluid.clip.GradientClipByNorm
+
+
+
 将输入的多维Tensor :math:`X` 的L2范数限制在 ``clip_norm`` 范围之内。
 
 - 如果L2范数大于 ``clip_norm`` ，则该 Tensor 会乘以一个系数进行压缩

doc/fluid/api_cn/clip_cn/GradientClipByValue_cn.rst

@@ -5,6 +5,12 @@ GradientClipByValue
 
 .. py:class:: paddle.fluid.clip.GradientClipByValue(max, min=None, need_clip=None)
 
+:alias_main: paddle.nn.GradientClipByValue
+:alias: paddle.nn.GradientClipByValue,paddle.nn.clip.GradientClipByValue
+:old_api: paddle.fluid.clip.GradientClipByValue
+
+
+
 
 将输入的多维Tensor :math:`X` 的值限制在 [min, max] 范围。
 

doc/fluid/api_cn/clip_cn/set_gradient_clip_cn.rst

@@ -3,10 +3,13 @@
 set_gradient_clip
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.clip.set_gradient_clip(clip, param_list=None, program=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. warning::
     此API对位置使用的要求较高，其必须位于组建网络之后， ``minimize`` 之前，因此在未来版本中可能被删除，故不推荐使用。推荐在 ``optimizer`` 初始化时设置梯度裁剪。
     有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。

doc/fluid/api_cn/dataset_cn/DatasetFactory_cn.rst

@@ -5,6 +5,9 @@ DatasetFactory
 
 .. py:class:: paddle.fluid.dataset.DatasetFactory
 
+
+
+
 DatasetFactory是一个按数据集名称创建数据集的 "工厂"，可以创建“QueueDataset”，“InMemoryDataset”或“FileInstantDataset”，默认为“QueueDataset”。
 
 

doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst

@@ -5,6 +5,9 @@ InMemoryDataset
 
 .. py:class:: paddle.fluid.dataset.InMemoryDataset
 
+
+
+
 InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类由DatasetFactory创建。
 
 **代码示例**:

doc/fluid/api_cn/dataset_cn/QueueDataset_cn.rst

@@ -5,6 +5,9 @@ QueueDataset
 
 .. py:class:: paddle.fluid.dataset.QueueDataset
 
+
+
+
 流式处理数据。
 
 **代码示例**:

doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst

@@ -3,10 +3,13 @@
 BackwardStrategy
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.BackwardStrategy
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 **注意：该API只在动态图下生效**
 
 BackwardStrategy是描述动态图反向执行的策略，主要功能是定义动态图反向执行时的不同策略

doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst

@@ -5,6 +5,12 @@ BatchNorm
 
 .. py:class:: paddle.fluid.dygraph.BatchNorm(num_channels, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, dtype='float32', data_layout='NCHW', in_place=False, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False, trainable_statistics=False)
 
+:alias_main: paddle.nn.BatchNorm
+:alias: paddle.nn.BatchNorm,paddle.nn.layer.BatchNorm,paddle.nn.layer.norm.BatchNorm
+:old_api: paddle.fluid.dygraph.BatchNorm
+
+
+
 该接口用于构建 ``BatchNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考 : `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当use_global_stats = False时，:math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是minibatch的统计数据。计算公式如下：

doc/fluid/api_cn/dygraph_cn/BilinearTensorProduct_cn.rst

@@ -5,6 +5,12 @@ 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::

doc/fluid/api_cn/dygraph_cn/Conv2DTranspose_cn.rst

@@ -5,6 +5,9 @@ Conv2DTranspose
 
 .. py:class:: paddle.fluid.dygraph.Conv2DTranspose(num_channels, num_filters, filter_size, output_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype="float32")
 
+
+
+
 该接口用于构建 ``Conv2DTranspose`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个二维卷积转置层（Convlution2D Transpose Layer），其根据输入（input）、滤波器参数（num_filters、filter_size）、步长（stride）、填充（padding）、膨胀系数（dilation）、组数（groups）来计算得到输出特征图。输入和输出是 ``NCHW`` 格式，N是批数据大小，C是特征图个数，H是特征图高度，W是特征图宽度。滤波器的维度是 [M, C, H, W] ，M是输入特征图个数，C是输出特征图个数，H是滤波器高度，W是滤波器宽度。如果组数大于1，C等于输入特征图个数除以组数的结果。如果提供了偏移属性和激活函数类型，卷积的结果会和偏移相加，激活函数会作用在最终结果上。转置卷积的计算过程相当于卷积的反向计算，转置卷积又被称为反卷积（但其实并不是真正的反卷积）。详情请参考： `Conv2DTranspose <http://www.matthewzeiler.com/wp-content/uploads/2017/07/cvpr2010.pdf>`_ 。
 
 输入 ``X`` 和输出 ``Out`` 的函数关系如下：

doc/fluid/api_cn/dygraph_cn/Conv2D_cn.rst

@@ -5,6 +5,9 @@ Conv2D
 
 .. py:class:: paddle.fluid.dygraph.Conv2D(num_channels, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype='float32')
 
+
+
+
 该接口用于构建 ``Conv2D`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个二维卷积层（Convolution2D Layer），其根据输入、滤波器参数（num_filters、filter_size）、步长（stride）、填充（padding）、膨胀系数（dilation）、组数（groups）参数来计算得到输出特征图。输入和输出是 ``NCHW`` 格式，N是批数据大小，C是特征图个数，H是特征图高度，W是特征图宽度。滤波器的维度是 [M, C, H, W] ，M是输出特征图个数，C是输入特征图个数，H是滤波器高度，W是滤波器宽度。如果组数大于1，C等于输入特征图个数除以组数的结果。如果提供了偏移属性和激活函数类型，卷积的结果会和偏移相加，激活函数会作用在最终结果上。详情请参考： `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。
 
 对每个输入 ``X`` ，有等式：

doc/fluid/api_cn/dygraph_cn/Conv3DTranspose_cn.rst

@@ -6,6 +6,9 @@ Conv3DTranspose
 .. py:class:: paddle.fluid.dygraph.Conv3DTranspose(num_channels, num_filters, filter_size, output_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, dtype="float32")
 
 
+
+
+
 该接口用于构建 ``Conv3DTranspose`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。3D卷积转置层（Convlution3D transpose layer)根据输入（input）、滤波器（filter）和卷积核膨胀（dilations）、步长（stride）、填充来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCDHW格式。其中 ``N`` 为batch大小， ``C`` 为通道数（channel）, ``D``  为特征深度, ``H`` 为特征高度， ``W`` 为特征宽度。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解卷积转置层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。如果act不为None，则转置卷积计算之后添加相应的激活函数。
 
 

doc/fluid/api_cn/dygraph_cn/Conv3D_cn.rst

@@ -6,6 +6,9 @@ Conv3D
 .. py:class:: paddle.fluid.dygraph.Conv3D(num_channels, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype="float32")
 
 
+
+
+
 该接口用于构建 ``Conv3D`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。3D卷积层（convolution3D layer）根据输入、滤波器（filter）、步长（stride）、填充（padding）、膨胀（dilations）、组数参数计算得到输出。输入和输出是[N, C, D, H, W]的多维tensor，其中N是批尺寸，C是通道数，D是特征深度，H是特征高度，W是特征宽度。卷积三维（Convlution3D）和卷积二维（Convlution2D）相似，但多了一维深度（depth）。如果提供了bias属性和激活函数类型，bias会添加到卷积（convolution）的结果中相应的激活函数会作用在最终结果上。
 
 对每个输入X，有等式：

doc/fluid/api_cn/dygraph_cn/CosineDecay_cn.rst

@@ -3,10 +3,13 @@
 CosineDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.CosineDecay(learning_rate, step_each_epoch, epochs, begin=0, step=1, dtype='float32')
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供按余弦函数衰减学习率的功能。
 
 余弦衰减的计算方式如下。

doc/fluid/api_cn/dygraph_cn/Embedding_cn.rst

@@ -5,6 +5,12 @@ Embedding
 
 .. py:class:: paddle.fluid.dygraph.Embedding(size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')
 
+:alias_main: paddle.nn.Embedding
+:alias: paddle.nn.Embedding,paddle.nn.layer.Embedding,paddle.nn.layer.common.Embedding
+:old_api: paddle.fluid.dygraph.Embedding
+
+
+
 嵌入层(Embedding Layer)
 
 该接口用于构建 ``Embedding`` 的一个可调用对象，具体用法参照 ``代码示例`` 。其根据input中的id信息从embedding矩阵中查询对应embedding信息，并会根据输入的size (vocab_size, emb_size)和dtype自动构造一个二维embedding矩阵。

doc/fluid/api_cn/dygraph_cn/ExponentialDecay_cn.rst

@@ -3,10 +3,13 @@
 ExponentialDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.ExponentialDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype=’float32‘)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供一种学习率按指数函数衰减的功能。
 
 指数衰减的计算方式如下。

doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst

@@ -5,6 +5,9 @@ GRUUnit
 
 .. py:class:: paddle.fluid.dygraph.GRUUnit(name_scope, size, param_attr=None, bias_attr=None, activation='tanh', gate_activation='sigmoid', origin_mode=False, dtype='float32')
 
+
+
+
 该接口用于构建 ``GRU(Gated Recurrent Unit)`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其用于完成单个时间步内GRU的计算，支持以下两种计算方式：
 
 如果origin_mode为True，则使用的运算公式来自论文

doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst

@@ -5,6 +5,12 @@ GroupNorm
 
 .. py:class:: paddle.fluid.dygraph.GroupNorm(channels, groups, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, data_layout='NCHW', dtype="float32")
 
+:alias_main: paddle.nn.GroupNorm
+:alias: paddle.nn.GroupNorm,paddle.nn.layer.GroupNorm,paddle.nn.layer.norm.GroupNorm
+:old_api: paddle.fluid.dygraph.GroupNorm
+
+
+
 **Group Normalization层**
 
 该接口用于构建 ``GroupNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了组归一化层的功能。更多详情请参考： `Group Normalization <https://arxiv.org/abs/1803.08494>`_ 。

doc/fluid/api_cn/dygraph_cn/InverseTimeDecay_cn.rst

@@ -3,10 +3,13 @@
 InverseTimeDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.InverseTimeDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype='float32')
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供反时限学习率衰减的功能。
 
 反时限学习率衰减计算方式如下。

doc/fluid/api_cn/dygraph_cn/LayerList_cn.rst

@@ -5,6 +5,9 @@ LayerList
 
 .. py:class:: paddle.fluid.dygraph.LayerList(sublayers=None)
 
+
+
+
 LayerList用于保存子层列表，它包含的子层将被正确地注册和添加。列表中的子层可以像常规python列表一样被索引。
 
 参数：

doc/fluid/api_cn/dygraph_cn/LayerNorm_cn.rst

@@ -5,6 +5,12 @@ LayerNorm
 
 .. py:class:: paddle.fluid.dygraph.LayerNorm(normalized_shape, scale=True, shift=True, begin_norm_axis=1, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, dtype="float32")
 
+:alias_main: paddle.nn.LayerNorm
+:alias: paddle.nn.LayerNorm,paddle.nn.layer.LayerNorm,paddle.nn.layer.norm.LayerNorm
+:old_api: paddle.fluid.dygraph.LayerNorm
+
+
+
 该接口用于构建 ``LayerNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了层归一化层（Layer Normalization Layer）的功能，其可以应用于小批量输入数据。更多详情请参考：`Layer Normalization <https://arxiv.org/pdf/1607.06450v1.pdf>`_
 
 计算公式如下

doc/fluid/api_cn/dygraph_cn/Layer_cn.rst

@@ -5,6 +5,9 @@ Layer
 
 .. py:class:: paddle.fluid.dygraph.Layer(name_scope=None, dtype=core.VarDesc.VarType.FP32)
 
+
+
+
 基于OOD实现的动态图Layer，包含该Layer的参数、前序运行的结构等信息。
 
 参数：

doc/fluid/api_cn/dygraph_cn/Linear_cn.rst

@@ -5,6 +5,12 @@ Linear
 
 .. py:class:: paddle.fluid.dygraph.Linear(input_dim, output_dim, param_attr=None, bias_attr=None, act=None, dtype='float32')
 
+:alias_main: paddle.nn.Linear
+:alias: paddle.nn.Linear,paddle.nn.layer.Linear,paddle.nn.layer.common.Linear
+:old_api: paddle.fluid.dygraph.Linear
+
+
+
 
 **线性变换层：**
 

doc/fluid/api_cn/dygraph_cn/NCE_cn.rst

@@ -5,6 +5,9 @@ NCE
 
 .. py:class:: paddle.fluid.dygraph.NCE(num_total_classes, dim, param_attr=None, bias_attr=None, num_neg_samples=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False, dtype="float32")
 
+
+
+
 该接口用于构建 ``NCE`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了 ``NCE`` 损失函数的功能，其默认使用均匀分布进行抽样，计算并返回噪音对比估计（ noise-contrastive estimation training loss）。更多详情请参考：`Noise-contrastive estimation: A new estimation principle for unnormalized statistical models <http://www.jmlr.org/proceedings/papers/v9/gutmann10a/gutmann10a.pdf>`_
 
 参数：

doc/fluid/api_cn/dygraph_cn/NaturalExpDecay_cn.rst

@@ -3,10 +3,13 @@
 NaturalExpDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.NaturalExpDecay(learning_rate, decay_steps, decay_rate, staircase=False, begin=0, step=1, dtype='float32')
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供按自然指数衰减学习率的功能。
 
 自然指数衰减的计算方式如下。

doc/fluid/api_cn/dygraph_cn/NoamDecay_cn.rst

@@ -3,10 +3,13 @@
 NoamDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.NoamDecay(d_model, warmup_steps, begin=1, step=1, dtype='float32', learning_rate=1.0)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供Noam衰减学习率的功能。
 
 Noam衰减的计算方式如下。

doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst

@@ -5,6 +5,9 @@ PRelu
 
 .. py:class:: paddle.fluid.dygraph.PRelu(mode, input_shape=None, param_attr=None, dtype="float32")
 
+
+
+
 该接口用于构建 ``PRelu`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了 ``PRelu`` 激活函数的三种激活方式。
 
 计算公式如下：

doc/fluid/api_cn/dygraph_cn/ParameterList_cn.rst

@@ -5,6 +5,9 @@ ParameterList
 
 .. py:class:: paddle.fluid.dygraph.ParameterList(parameters=None)
 
+
+
+
 参数列表容器。此容器的行为类似于Python列表，但它包含的参数将被正确地注册和添加。
 
 参数：

doc/fluid/api_cn/dygraph_cn/PiecewiseDecay_cn.rst

@@ -3,10 +3,13 @@
 PiecewiseDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.PiecewiseDecay(boundaries, values, begin, step=1, dtype='float32')
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供对初始学习率进行分段(piecewise)常数衰减的功能。
 
 分段常数衰减的过程举例描述如下。

doc/fluid/api_cn/dygraph_cn/PolynomialDecay_cn.rst

@@ -3,10 +3,13 @@
 PolynomialDecay
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.PolynomialDecay(learning_rate, decay_steps, end_learning_rate=0.0001, power=1.0, cycle=False, begin=0, step=1, dtype='float32')
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口提供学习率按多项式衰减的功能。通过多项式衰减函数，使得学习率值逐步从初始的 ``learning_rate``，衰减到 ``end_learning_rate`` 。
 
 计算方式如下。

doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst

@@ -5,6 +5,12 @@ Pool2D
 
 .. py:class:: paddle.fluid.dygraph.Pool2D(pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, exclusive=True)
 
+:alias_main: paddle.nn.Pool2D
+:alias: paddle.nn.Pool2D,paddle.nn.layer.Pool2D,paddle.nn.layer.common.Pool2D
+:old_api: paddle.fluid.dygraph.Pool2D
+
+
+
 该接口用于构建 ``Pool2D`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个二维池化层，并使用上述输入参数的池化配置，为二维空间池化操作，根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核大小 ``pool_size`` , 步长 ``pool_stride`` ，填充 ``pool_padding`` 这些参数得到输出。
 
 输入X和输出Out是NCHW格式，N为批大小，C是通道数，H是特征高度，W是特征宽度。参数（ ``ksize``, ``strides``, ``paddings`` ）含有两个整型元素。分别表示高度和宽度上的参数。输入X的大小和输出Out的大小可能不一致。

doc/fluid/api_cn/dygraph_cn/Sequential_cn.rst

@@ -5,6 +5,9 @@ Sequential
 
 .. py:class:: paddle.fluid.dygraph.Sequential(*layers)
 
+
+
+
 顺序容器。子Layer将按构造函数参数的顺序添加到此容器中。传递给构造函数的参数可以Layers或可迭代的name Layer元组。
 
 参数：

doc/fluid/api_cn/dygraph_cn/SpectralNorm_cn.rst

@@ -5,6 +5,12 @@ SpectralNorm
 
 .. py:class:: paddle.fluid.dygraph.SpectralNorm(weight_shape, dim=0, power_iters=1, eps=1e-12, name=None, dtype="float32")
 
+:alias_main: paddle.nn.SpectralNorm
+:alias: paddle.nn.SpectralNorm,paddle.nn.layer.SpectralNorm,paddle.nn.layer.norm.SpectralNorm
+:old_api: paddle.fluid.dygraph.SpectralNorm
+
+
+
 该接口用于构建 ``SpectralNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了谱归一化层的功能，用于计算fc、conv1d、conv2d、conv3d层的权重参数的谱正则值，输入权重参数应分别为2-D, 3-D, 4-D, 5-D张量，输出张量与输入张量维度相同。谱特征值计算方式如下：
 
 步骤1：生成形状为[H]的向量U,以及形状为[W]的向量V,其中H是输入权重张量的第 ``dim`` 个维度，W是剩余维度的乘积。

doc/fluid/api_cn/dygraph_cn/TracedLayer_cn.rst

@@ -3,10 +3,13 @@
 TracedLayer
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:class:: paddle.fluid.dygraph.TracedLayer(program, parameters, feed_names, fetch_names)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 TracedLayer用于将前向动态图模型转换为静态图模型，主要用于将动态图保存后做在线C++预测。除此以外，用户也可使用转换后的静态图模型在Python端做预测，通常比原先的动态图性能更好。
 
 TracedLayer使用 ``Executor`` 和 ``CompiledProgram`` 运行静态图模型。转换后的静态图模型与原动态图模型共享参数。

doc/fluid/api_cn/dygraph_cn/TreeConv_cn.rst

@@ -5,6 +5,9 @@ TreeConv
 
 .. py:class:: paddle.fluid.dygraph.TreeConv(feature_size, output_size, num_filters=1, max_depth=2, act='tanh', param_attr=None, bias_attr=None, name=None, dtype="float32")
 
+
+
+
 该接口用于构建 ``TreeConv`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个基于树结构的卷积（Tree-Based Convolution）运算。基于树的卷积是基于树的卷积神经网络（TBCNN，Tree-Based Convolution Neural Network）的一部分，它用于对树结构进行分类，例如抽象语法树。 Tree-Based Convolution提出了一种称为连续二叉树的数据结构，它将多路（multiway）树视为二叉树。详情请参考： `基于树的卷积论文 <https://arxiv.org/abs/1409.5718v1>`_ 。
 
 

doc/fluid/api_cn/dygraph_cn/guard_cn.rst

@@ -3,10 +3,13 @@
 guard
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:function:: paddle.fluid.dygraph.guard(place=None)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 通过with语句创建一个dygraph运行的context，执行context代码。
 
 参数：

doc/fluid/api_cn/dygraph_cn/load_dygraph_cn.rst

@@ -3,10 +3,13 @@
 load_dygraph
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:function:: paddle.fluid.dygraph.load_dygraph(model_path)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口尝试从磁盘中加载参数或优化器的 ``dict`` 。
 
 该接口会同时加载 ``model_path + ".pdparams"`` 和 ``model_path + ".pdopt"`` 中的内容。

doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst

@@ -3,10 +3,13 @@
 no_grad
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:method:: paddle.fluid.dygraph.no_grad(func=None)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 创建一个上下文来禁用动态图梯度计算。在此模式下，每次计算的结果都将具有stop_gradient=True。
 
 也可以用作一个装饰器（确保不要用括号来初始化）。

doc/fluid/api_cn/dygraph_cn/prepare_context_cn.rst

@@ -5,6 +5,10 @@ prepare_context
 
 .. py:class:: paddle.fluid.dygraph.prepare_context(strategy=None)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该API是进行多进程多卡训练的环境配置接口，接受一个ParallelStrategy结构体变量作为输入。当strategy属性中的nums_trainer小于2时，API会直接返回，当nums_trainer大于1且为CUDAPlace时，由于目前动态图模式仅支持GPU多卡训练，仅能配置NCCL多卡训练的环境，所以此时会对NCCL环境进行配置，具体内容包括：生成NCCL ID，并广播至参与训练的各进程，用于支持的处理器同步操作，创建并配置NCCL通信器等。
 
 参数：

doc/fluid/api_cn/dygraph_cn/save_dygraph_cn.rst

@@ -3,10 +3,13 @@
 save_dygraph
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:function:: paddle.fluid.dygraph.save_dygraph(state_dict, model_path)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该接口将传入的参数或优化器的 ``dict`` 保存到磁盘上。
 
 ``state_dict`` 是通过 :ref:`cn_api_fluid_dygraph_Layer` 的 ``state_dict()`` 方法得到的。

doc/fluid/api_cn/dygraph_cn/to_variable_cn.rst

@@ -3,10 +3,13 @@
 to_variable
 -------------------------------
 
-**注意：该API仅支持【动态图】模式**
 
 .. py:function:: paddle.fluid.dygraph.to_variable(value, name=None, zero_copy=None)
 
+:api_attr: 命令式编程模式（动态图)
+
+
+
 该函数实现从numpy\.ndarray对象或者Variable对象创建一个 ``Variable`` 类型的对象。
 
 参数：

doc/fluid/api_cn/executor_cn/Executor_cn.rst

@@ -3,10 +3,13 @@
 Executor
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.executor.Executor (place=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 Executor支持单GPU、多GPU以及CPU运行。
 
 参数：

doc/fluid/api_cn/executor_cn/global_scope_cn.rst

@@ -3,10 +3,13 @@
 global_scope
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.global_scope()
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 获取全局/默认作用域实例。很多API使用默认 ``global_scope`` ，例如 ``Executor.run`` 等。
 
 返回：全局/默认作用域实例

doc/fluid/api_cn/executor_cn/scope_guard_cn.rst

@@ -3,10 +3,13 @@
 scope_guard
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.executor.scope_guard (scope)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 该接口通过 python 的 ``with`` 语句切换作用域（scope）。
 作用域记录了变量名和变量 ( :ref:`api_guide_Variable` ) 之间的映射关系，类似于编程语言中的大括号。

doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst

@@ -3,10 +3,13 @@
 BuildStrategy
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.BuildStrategy
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 ``BuildStrategy`` 使用户更方便地控制 :ref:`cn_api_fluid_ParallelExecutor` 中计算图的建造方法，可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。
 
 **代码示例**

doc/fluid/api_cn/fluid_cn/CPUPlace_cn.rst

@@ -5,6 +5,9 @@ CPUPlace
 
 .. py:class:: paddle.fluid.CPUPlace
 
+
+
+
 ``CPUPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 或 ``LoDTensor`` 的 ``CPU`` 设备。
 
 **代码示例**

doc/fluid/api_cn/fluid_cn/CUDAPinnedPlace_cn.rst

@@ -5,6 +5,9 @@ CUDAPinnedPlace
 
 .. py:class:: paddle.fluid.CUDAPinnedPlace
 
+
+
+
 ``CUDAPinnedPlace`` 是一个设备描述符，它所指代的页锁定内存由 CUDA 函数 ``cudaHostAlloc()`` 在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝。
 有关 CUDA 的数据转移和 ``pinned memory``，参见 `官方文档 <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ 。
 

doc/fluid/api_cn/fluid_cn/CUDAPlace_cn.rst

@@ -5,6 +5,9 @@ CUDAPlace
 
 .. py:class:: paddle.fluid.CUDAPlace
 
+
+
+
 .. note::
     多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的GPU设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
 

doc/fluid/api_cn/fluid_cn/CompiledProgram_cn.rst

@@ -3,10 +3,13 @@
 CompiledProgram
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.CompiledProgram(program_or_graph, build_strategy=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 CompiledProgram根据 `build_strategy` 的配置将输入的Program或Graph进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等，关于build_strategy更多信息。请参阅  ``fluid.BuildStrategy`` 。
 
 参数：

doc/fluid/api_cn/fluid_cn/DataFeedDesc_cn.rst

@@ -3,10 +3,13 @@
 DataFeedDesc
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.DataFeedDesc(proto_file)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 描述训练数据的格式。输入是一个文件路径名，其内容是protobuf message。
 
 可以参考 :code:`paddle/fluid/framework/data_feed.proto` 查看我们如何定义message

doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst

@@ -3,10 +3,13 @@
 DataFeeder
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.DataFeeder(feed_list, place, program=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 
 ``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。

doc/fluid/api_cn/fluid_cn/DistributeTranspilerConfig_cn.rst

@@ -6,6 +6,9 @@ DistributeTranspilerConfig
 .. py:class:: paddle.fluid.DistributeTranspilerConfig
 
 
+
+
+
 .. py:attribute:: slice_var_up (bool)
 
 为多个Pserver（parameter server）将tensor切片, 默认为True。

doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst

@@ -6,6 +6,9 @@ DistributeTranspiler
 .. py:class:: paddle.fluid.DistributeTranspiler (config=None)
 
 
+
+
+
 该类可以把fluid program转变为分布式数据并行计算的program, 有PServer和NCCL2两种模式。
 在Pserver（全称：parameter server）模式下， 通过 ``transpile`` 将用于单机训练的 ``program``  转译为可用于parameter server的分布式架构(即PServer,参数服务器)来进行训练的program。
 在NCCL2模式下, 通过 ``transpile`` 将用于单机训练的 ``program``  转译为可用于NCCL2的分布式架构来进行训练的program。在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播

doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst

@@ -3,10 +3,13 @@
 ExecutionStrategy
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.ExecutionStrategy
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 通过设置 ``ExecutionStrategy`` 中的选项，用户可以对执行器的执行配置进行调整，比如设置执行器中线程池的大小等。
 
 返回：初始化后的ExecutionStrategy的实例

doc/fluid/api_cn/fluid_cn/Executor_cn.rst

@@ -4,10 +4,13 @@ Executor
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.Executor (place=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 Executor支持单GPU、多GPU以及CPU运行。
 
 参数：

doc/fluid/api_cn/fluid_cn/LoDTensorArray_cn.rst

@@ -5,6 +5,9 @@ LoDTensorArray
 
 .. py:class:: paddle.fluid.LoDTensorArray
 
+
+
+
 LoDTensorArray是由LoDTensor组成的数组，支持"[]"运算符、len()函数和for迭代等。
 
 **示例代码**

doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst

@@ -6,6 +6,9 @@ LoDTensor
 .. py:class:: paddle.fluid.LoDTensor
 
 
+
+
+
 LoDTensor是一个具有LoD（Level of Details）信息的张量（Tensor），可用于表示变长序列，详见 :ref:`cn_user_guide_lod_tensor` 。
 
 LoDTensor可以通过 ``np.array(lod_tensor)`` 方法转换为numpy.ndarray。

doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst

@@ -3,10 +3,13 @@
 ParallelExecutor
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.ParallelExecutor(use_cuda, loss_name=None, main_program=None, share_vars_from=None, exec_strategy=None, build_strategy=None, num_trainers=1, trainer_id=0, scope=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 ``ParallelExecutor`` 是 ``Executor`` 的一个升级版本，可以支持基于数据并行的多节点模型训练和测试。如果采用数据并行模式， ``ParallelExecutor`` 在构造时会将参数分发到不同的节点上，并将输入的 ``Program`` 拷贝到不同的节点，在执行过程中，各个节点独立运行模型，将模型反向计算得到的参数梯度在多个节点之间进行聚合，之后各个节点独立的进行参数的更新。如果使用GPU运行模型，即 ``use_cuda=True`` ，节点指代GPU， ``ParallelExecutor`` 将自动获取在当前机器上可用的GPU资源，用户也可以通过在环境变量设置可用的GPU资源，例如：希望使用GPU0、GPU1计算，export CUDA_VISIBLEDEVICES=0,1；如果在CPU上进行操作，即 ``use_cuda=False`` ，节点指代CPU，**注意：此时需要用户在环境变量中手动添加 CPU_NUM ，并将该值设置为CPU设备的个数，例如：export CPU_NUM=4，如果没有设置该环境变量，执行器会在环境变量中添加该变量，并将其值设为1**。
 
 参数:

doc/fluid/api_cn/fluid_cn/ParamAttr_cn.rst

@@ -7,6 +7,9 @@ ParamAttr
 
 .. py:class:: paddle.fluid.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False)
 
+
+
+
 .. note::
     该类中的 ``gradient_clip`` 属性在2.0版本会废弃，推荐在初始化 ``optimizer`` 时设置梯度裁剪。共有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、 
     :ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。

doc/fluid/api_cn/fluid_cn/Program_cn.rst

@@ -5,6 +5,9 @@ Program
 
 .. py:class::  paddle.fluid.Program
 
+
+
+
 **注意：默认情况下，Paddle Fluid内部默认含有** :ref:`cn_api_fluid_default_startup_program` **和** :ref:`cn_api_fluid_default_main_program` **，它们共享参数。** :ref:`cn_api_fluid_default_startup_program` **只运行一次来初始化参数，** :ref:`cn_api_fluid_default_main_program` **在每个mini batch中运行并更新权重。**
 
 Program是Paddle Fluid对于计算图的一种静态描述，使用Program的构造函数可以创建一个Program。Program中包括至少一个 :ref:`api_guide_Block` ，当 :ref:`api_guide_Block` 中存在条件选择的控制流OP（例如 :ref:`cn_api_fluid_layers_While` 等）时，该Program将会含有嵌套着的 :ref:`api_guide_Block` 即控制流外部的 :ref:`api_guide_Block` 将包含着控制流内部的 :ref:`api_guide_Block` ，而嵌套的 :ref:`api_guide_Block` 的元素访问控制将由具体的控制流OP来决定。关于Program具体的结构和包含的类型请参阅 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_

doc/fluid/api_cn/fluid_cn/Tensor_cn.rst

@@ -5,6 +5,9 @@ Tensor
 
 .. py:function:: paddle.fluid.Tensor
 
+
+
+
 Tensor用于表示多维张量，可以通过 ``np.array(tensor)`` 方法转换为numpy.ndarray。
 
 **示例代码**

doc/fluid/api_cn/fluid_cn/Variable_cn.rst

@@ -5,6 +5,9 @@ Variable
 
 .. py:class:: paddle.fluid.Variable
 
+
+
+
 **注意：**
   **1. 请不要直接调用** `Variable` **的构造函数，因为这会造成严重的错误发生！**
 

doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst

@@ -3,10 +3,13 @@
 WeightNormParamAttr
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     该类中的 ``gradient_clip`` 属性在2.0版本会废弃，推荐在初始化 ``optimizer`` 时设置梯度裁剪。共有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、 
     :ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。

doc/fluid/api_cn/fluid_cn/cpu_places_cn.rst

@@ -5,6 +5,9 @@ cpu_places
 
 .. py:function:: paddle.fluid.cpu_places(device_count=None)
 
+
+
+
 该接口创建 ``device_count`` 个 ``fluid.CPUPlace`` 对象，并返回所创建的对象列表。
 
 如果 ``device_count`` 为 ``None``，则设备数目将由环境变量 ``CPU_NUM`` 确定。如果未设置 ``CPU_NUM`` 环境变量，则设备数目会默认设为1，也就是说， ``CPU_NUM=1``。

doc/fluid/api_cn/fluid_cn/create_lod_tensor_cn.rst

@@ -6,6 +6,9 @@ create_lod_tensor
 
 .. py:function:: paddle.fluid.create_lod_tensor(data, recursive_seq_lens, place)
 
+
+
+
 从一个numpy数组、list或LoDTensor创建一个新的LoDTensor。
 
 具体实现方法如下:

doc/fluid/api_cn/fluid_cn/create_random_int_lodtensor_cn.rst

@@ -4,10 +4,13 @@
 create_random_int_lodtensor
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low, high)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 创建一个包含随机整数的LoDTensor。
 
 具体实现方法如下：

doc/fluid/api_cn/fluid_cn/cuda_pinned_places_cn.rst

@@ -8,6 +8,9 @@ cuda_pinned_places
 
 
 
+
+
+
 该接口创建 ``device_count`` 个 ``fluid.CUDAPinnedPlace`` ( fluid. :ref:`cn_api_fluid_CUDAPinnedPlace` ) 对象，并返回所创建的对象列表。
 
 如果 ``device_count`` 为 ``None``，实际设备数目将由当前任务中使用的GPU设备数决定。用户可通过以下2种方式设置任务可用的GPU设备：

doc/fluid/api_cn/fluid_cn/cuda_places_cn.rst

@@ -5,6 +5,9 @@ cuda_places
 
 .. py:function:: paddle.fluid.cuda_places(device_ids=None)
 
+
+
+
 .. note::
     多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的GPU设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
 

doc/fluid/api_cn/fluid_cn/data_cn.rst

@@ -3,10 +3,16 @@
 data
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.data(name, shape, dtype='float32', lod_level=0)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.data
+:alias: paddle.nn.data,paddle.nn.input.data
+:old_api: paddle.fluid.data
+
+
+
 该OP会在全局block中创建变量（Variable），该全局变量可被计算图中的算子（operator）访问。该变量可作为占位符用于数据输入。例如用执行器（Executor）feed数据进该变量
 
 注意：

doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst

@@ -6,6 +6,9 @@ default_main_program
 .. py:function:: paddle.fluid.default_main_program()
 
 
+
+
+
 此接口可以获取当前用于存储op和variable描述信息的 ``default main program``
 
 ``fluid.layers`` 接口中添加的op和variable会存储在 ``default main program`` 中

doc/fluid/api_cn/fluid_cn/default_startup_program_cn.rst

@@ -10,6 +10,9 @@ default_startup_program
 
 
 
+
+
+
 该函数可以获取默认/全局 startup :ref:`cn_api_fluid_Program` (初始化启动程序)。
 
  :ref:`_cn_api_fluid_layers` 中的函数会新建参数或 :ref:`cn_api_paddle_data_reader_reader` (读取器) 或 `NCCL <https://developer.nvidia.com/nccl>`_ 句柄作为全局变量。

doc/fluid/api_cn/fluid_cn/embedding_cn.rst

@@ -3,10 +3,13 @@
 embedding
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.embedding(input, size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP根据input中的id信息从embedding矩阵中查询对应embedding信息，函数会根据输入的size (vocab_size, emb_size)和dtype自动构造一个二维embedding矩阵。
 
 输出的Tensor的shape是在输入Tensor shape的最后一维后面添加了emb_size的维度。

doc/fluid/api_cn/fluid_cn/global_scope_cn.rst

@@ -3,10 +3,13 @@
 global_scope
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.global_scope()
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 获取全局/默认作用域实例。很多API使用默认 ``global_scope`` ，例如 ``Executor.run`` 等。
 
 返回：全局/默认作用域实例

doc/fluid/api_cn/fluid_cn/gradients_cn.rst

@@ -3,10 +3,13 @@
 gradients
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 将目标梯度反向传播到输入。
 
 参数：  

doc/fluid/api_cn/fluid_cn/in_dygraph_mode_cn.rst

@@ -5,6 +5,9 @@ in_dygraph_mode
 
 .. py:function:: paddle.fluid.in_dygraph_mode()
 
+
+
+
 该接口检查程序是否在动态图模式中运行。
 可以通过 ``fluid.dygraph.guard`` 接口开启动态图模式。
 

doc/fluid/api_cn/fluid_cn/is_compiled_with_cuda_cn.rst

@@ -5,6 +5,9 @@ is_compiled_with_cuda
 
 .. py:function:: paddle.fluid.is_compiled_with_cuda()
 
+
+
+
 检查 ``whl`` 包是否可以被用来在GPU上运行模型
 
 返回：支持gpu则为True,否则为False。

doc/fluid/api_cn/fluid_cn/load_cn.rst

@@ -5,6 +5,10 @@ load
 
 .. py:function:: paddle.fluid.load(program, model_path, executor=None, var_list=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从Program中过滤出参数和优化器信息，然后从文件中获取相应的值。
 
 如果Program和加载的文件之间参数的维度或数据类型不匹配，将引发异常。

doc/fluid/api_cn/fluid_cn/load_op_library_cn.rst

@@ -5,6 +5,10 @@ load_op_library
 
 .. py:class:: paddle.fluid.load_op_library
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 ``load_op_library`` 用于自定义C++算子中，用来加载算子动态共享库。加载库后，注册好的算子及其Kernel实现将在PaddlePaddle主进程中可以被调用。 请注意，自定义算子的类型不能与框架中的现有算子类型相同。
 
 参数：

doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst

@@ -3,9 +3,12 @@
 memory_optimize
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**
 

doc/fluid/api_cn/fluid_cn/name_scope_cn.rst

@@ -3,10 +3,13 @@
 name_scope
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.name_scope(prefix=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 该函数为operators生成不同的命名空间。该函数只用于调试和可视化，不建议用在其它方面。
 

doc/fluid/api_cn/fluid_cn/one_hot_cn.rst

@@ -5,6 +5,12 @@ one_hot
 
 .. py:function:: paddle.fluid.one_hot(input, depth, allow_out_of_range=False)
 
+:alias_main: paddle.nn.functional.one_hot
+:alias: paddle.nn.functional.one_hot,paddle.nn.functional.common.one_hot
+:old_api: paddle.fluid.one_hot
+
+
+
 该OP将输入（input）中的每个id转换为一个one-hot向量，其长度为 ``depth`` ，该id对应的向量维度上的值为1，其余维度的值为0。
 
 输出的Tensor（或LoDTensor）的shape是在输入shape的最后一维后面添加了depth的维度。

doc/fluid/api_cn/fluid_cn/program_guard_cn.rst

@@ -3,10 +3,13 @@
 program_guard
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.program_guard(main_program, startup_program=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口应配合使用python的 ``with`` 语句来将 ``with`` block 里的算子和变量添加进指定的全局主程序（main program）和启动程序（startup program）。
 
 ``with`` 语句块中的fluid.layers下各接口将在新的main program（主程序）中添加operators（算子）和variables（变量）。

doc/fluid/api_cn/fluid_cn/release_memory_cn.rst

@@ -3,8 +3,11 @@
 release_memory
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.release_memory(input_program, skip_opt_set=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**

doc/fluid/api_cn/fluid_cn/require_version_cn.rst

@@ -4,6 +4,9 @@ require_version
 -------------------------------
 
 .. py:function:: paddle.fluid.require_version(min_version, max_version=None)
+
+
+
 该接口用于检查已安装的飞桨版本是否介于[``min_version``, ``max_version``]之间（包含 ``min_version`` 和 ``max_version`` ），如果已安装的版本低于 ``min_version`` 或者高于 ``max_version`` ，将会抛出异常。该接口无返回值。
 
 参数:

doc/fluid/api_cn/fluid_cn/save_cn.rst

@@ -3,10 +3,16 @@
 save
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.save(program, model_path)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.save
+:alias: paddle.save,paddle.tensor.save,paddle.tensor.io.save
+:old_api: paddle.fluid.save
+
+
+
 该接口将传入的参数、优化器信息和网络描述保存到 ``model_path`` 。
 
 参数包含所有的可训练 :ref:`cn_api_fluid_Variable` ，将保存到后缀为 ``.pdparams`` 的文件中。

doc/fluid/api_cn/fluid_cn/scope_guard_cn.rst

@@ -3,10 +3,13 @@
 scope_guard
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.scope_guard(scope)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 该接口通过 python 的 ``with`` 语句切换作用域（scope）。
 作用域记录了变量名和变量 ( :ref:`api_guide_Variable` ) 之间的映射关系，类似于编程语言中的大括号。

doc/fluid/api_cn/framework_cn/manual_seed_cn.rst

@@ -5,6 +5,11 @@ 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参数设置成相同的种子
 

doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst

@@ -5,6 +5,9 @@ BilinearInitializer
 
 .. py:class:: paddle.fluid.initializer.BilinearInitializer())
 
+
+
+
 该接口为参数初始化函数，用于转置卷积函数中，对输入进行上采样。用户通过任意整型因子放大shape为(B，C，H，W)的特征图。
 
 返回：对象

doc/fluid/api_cn/initializer_cn/Bilinear_cn.rst

@@ -5,6 +5,12 @@ Bilinear
 
 .. py:attribute:: paddle.fluid.initializer.Bilinear
 
+:alias_main: paddle.nn.initializer.Bilinear
+:alias: paddle.nn.initializer.Bilinear
+:old_api: paddle.fluid.initializer.Bilinear
+
+
+
 ``BilinearInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/ConstantInitializer_cn.rst

@@ -5,6 +5,9 @@ ConstantInitializer
 
 .. py:class:: paddle.fluid.initializer.ConstantInitializer(value=0.0, force_cpu=False)
 
+
+
+
 该接口为常量初始化函数，用于权重初始化，通过输入的value值初始化输入变量；
 
 参数：

doc/fluid/api_cn/initializer_cn/Constant_cn.rst

@@ -5,6 +5,12 @@ Constant
 
 .. py:attribute:: paddle.fluid.initializer.Constant
 
+:alias_main: paddle.nn.initializer.Constant
+:alias: paddle.nn.initializer.Constant
+:old_api: paddle.fluid.initializer.Constant
+
+
+
 ``ConstantInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/MSRAInitializer_cn.rst

@@ -5,6 +5,9 @@ MSRAInitializer
 
 .. py:class:: paddle.fluid.initializer.MSRAInitializer(uniform=True, fan_in=None, seed=0)
 
+
+
+
 该接口实现MSRA方式的权重初始化（a.k.a. Kaiming初始化）
 
 该接口为权重初始化函数，方法来自Kaiming He，Xiangyu Zhang，Shaoqing Ren 和 Jian Sun所写的论文: `Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification <https://arxiv.org/abs/1502.01852>`_ 。这是一个鲁棒性特别强的初始化方法，并且适应了非线性激活函数（rectifier nonlinearities）。

doc/fluid/api_cn/initializer_cn/MSRA_cn.rst

@@ -5,5 +5,11 @@ MSRA
 
 .. py:attribute:: paddle.fluid.initializer.MSRA
 
+:alias_main: paddle.nn.initializer.MSRA
+:alias: paddle.nn.initializer.MSRA
+:old_api: paddle.fluid.initializer.MSRA
+
+
+
 ``MSRAInitializer`` 的别名
 

doc/fluid/api_cn/initializer_cn/NormalInitializer_cn.rst

@@ -5,6 +5,9 @@ NormalInitializer
 
 .. py:class:: paddle.fluid.initializer.NormalInitializer(loc=0.0, scale=1.0, seed=0)
 
+
+
+
 随机正态(高斯)分布初始化函数
 
 参数：

doc/fluid/api_cn/initializer_cn/Normal_cn.rst

@@ -5,6 +5,12 @@ Normal
 
 .. py:attribute:: paddle.fluid.initializer.Normal
 
+:alias_main: paddle.nn.initializer.Normal
+:alias: paddle.nn.initializer.Normal
+:old_api: paddle.fluid.initializer.Normal
+
+
+
 ``NormalInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/NumpyArrayInitializer_cn.rst

@@ -5,6 +5,9 @@ NumpyArrayInitializer
 
 .. py:class:: paddle.fluid.initializer.NumpyArrayInitializer(value)
 
+
+
+
 该OP使用Numpy型数组来初始化参数变量。
 
 参数：

doc/fluid/api_cn/initializer_cn/TruncatedNormalInitializer_cn.rst

@@ -5,6 +5,9 @@ TruncatedNormalInitializer
 
 .. py:class:: paddle.fluid.initializer.TruncatedNormalInitializer(loc=0.0, scale=1.0, seed=0)
 
+
+
+
 Random Truncated Normal(高斯)分布初始化函数
 
 参数：

doc/fluid/api_cn/initializer_cn/TruncatedNormal_cn.rst

@@ -5,6 +5,12 @@ TruncatedNormal
 
 .. py:attribute:: paddle.fluid.initializer.TruncatedNormal
 
+:alias_main: paddle.nn.initializer.TruncatedNormal
+:alias: paddle.nn.initializer.TruncatedNormal
+:old_api: paddle.fluid.initializer.TruncatedNormal
+
+
+
 ``TruncatedNormalInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/UniformInitializer_cn.rst

@@ -5,6 +5,9 @@ UniformInitializer
 
 .. py:class:: paddle.fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0) 
 
+
+
+
 随机均匀分布初始化器
 
 参数：

doc/fluid/api_cn/initializer_cn/Uniform_cn.rst

@@ -5,6 +5,12 @@ Uniform
 
 .. py:attribute:: paddle.fluid.initializer.Uniform
 
+:alias_main: paddle.nn.initializer.Uniform
+:alias: paddle.nn.initializer.Uniform
+:old_api: paddle.fluid.initializer.Uniform
+
+
+
 ``UniformInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/XavierInitializer_cn.rst

@@ -5,6 +5,9 @@ XavierInitializer
 
 .. py:class:: paddle.fluid.initializer.XavierInitializer(uniform=True, fan_in=None, fan_out=None, seed=0)
 
+
+
+
 该类实现Xavier权重初始化方法（ Xavier weight initializer），Xavier权重初始化方法出自Xavier Glorot和Yoshua Bengio的论文 `Understanding the difficulty of training deep feedforward neural networks <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_
 
 该初始化函数用于保持所有层的梯度尺度几乎一致。

doc/fluid/api_cn/initializer_cn/Xavier_cn.rst

@@ -5,6 +5,12 @@ Xavier
 
 .. py:attribute:: paddle.fluid.initializer.Xavier
 
+:alias_main: paddle.nn.initializer.Xavier
+:alias: paddle.nn.initializer.Xavier
+:old_api: paddle.fluid.initializer.Xavier
+
+
+
 ``XavierInitializer`` 的别名
 
 

doc/fluid/api_cn/initializer_cn/force_init_on_cpu_cn.rst

@@ -5,6 +5,9 @@ force_init_on_cpu
 
 .. py:function:: paddle.fluid.initializer.force_init_on_cpu()
 
+
+
+
 该接口获得一个是否强制在CPU上初始化变量的布尔型标志位。
 
 返回：状态，是否应强制在CPU上强制进行变量初始化

doc/fluid/api_cn/initializer_cn/init_on_cpu_cn.rst

@@ -5,6 +5,9 @@ init_on_cpu
 
 .. py:function:: paddle.fluid.initializer.init_on_cpu()
 
+
+
+
 该接口设置强制变量在 cpu 上初始化。
 
 返回：无

doc/fluid/api_cn/io_cn/DataLoader_cn.rst

@@ -6,6 +6,9 @@ DataLoader
 .. py:class:: paddle.fluid.io.DataLoader
 
 
+
+
+
 .. py:method:: from_generator(feed_list=None, capacity=None, use_double_buffer=True, iterable=True, return_list=False, use_multiprocess=False, drop_last=True)
 
 .. note::

doc/fluid/api_cn/io_cn/PyReader_cn.rst

@@ -6,6 +6,9 @@ PyReader
 .. py:class:: paddle.fluid.io.PyReader(feed_list=None, capacity=None, use_double_buffer=True, iterable=True, return_list=False)
 
 
+
+
+
 在python中为数据输入创建一个reader对象。将使用python线程预取数据，并将其异步插入队列。当调用Executor.run（…）时，将自动提取队列中的数据。 
 
 参数:

doc/fluid/api_cn/io_cn/batch_cn.rst

@@ -5,6 +5,9 @@ batch
 
 .. py:function:: paddle.fluid.io.batch(reader, batch_size, drop_last=False)
 
+
+
+
 该接口是一个reader的装饰器。返回的reader将输入reader的数据打包成指定的batch_size大小的批处理数据（batched data）。
 
 参数：

doc/fluid/api_cn/io_cn/buffered_cn.rst

@@ -5,6 +5,9 @@ buffered
 
 .. py:function:: paddle.fluid.io.buffered(reader, size)
 
+
+
+
 创建一个缓存数据读取器，它读取数据并且存储进缓存区，从缓存区读取数据将会加速，只要缓存不是空的。
 
 参数:

doc/fluid/api_cn/io_cn/cache_cn.rst

@@ -5,6 +5,9 @@ cache
 
 .. py:function:: paddle.fluid.io.cache(reader)
 
+
+
+
 缓存reader数据到内存中，小心此方法可能会花长时间来处理数据，并且会占用大量内存。 ``reader()`` 只能被调用一次。
 
 参数:

doc/fluid/api_cn/io_cn/chain_cn.rst

@@ -5,6 +5,9 @@ chain
 
 .. py:function:: paddle.fluid.io.chain(*readers)
 
+
+
+
 该接口将多个数据读取器组成一个数据读取器，它依次返回多个数据读取器的输出数据，同时不改变输出数据原先的格式。
 
 举例来说，如果有3个输入读取器且输出分别为[0，0，0]、[10，10，10]和[20，20，20]，那么调用该接口产生的新数据读取器的输出为[0，0，0], [10，10，10], [20，20，20]。

doc/fluid/api_cn/io_cn/compose_cn.rst

@@ -5,6 +5,9 @@ compose
 
 .. py:function:: paddle.fluid.io.compose(*readers, **kwargs)
 
+
+
+
 该接口将多个数据读取器组合为一个数据读取器，返回读取器的输出包含所有输入读取器的输出。
 
 例如：如果输入为三个reader，三个reader的输出分别为：（1，2）、3、（4，5），则组合reader的输出为：（1，2，3，4，5）。

doc/fluid/api_cn/io_cn/firstn_cn.rst

@@ -5,6 +5,9 @@ firstn
 
 .. py:function:: paddle.fluid.io.firstn(reader, n)
 
+
+
+
 该接口创建一个数据读取器，它可以返回的最大样本数为n。
 
 参数：

doc/fluid/api_cn/io_cn/get_program_parameter_cn.rst

@@ -5,6 +5,10 @@ get_program_parameter
 
 .. py:function:: paddle.fluid.io.get_program_parameter(program)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从Program中获取所有参数。
 
 参数:

doc/fluid/api_cn/io_cn/get_program_persistable_vars_cn.rst

@@ -5,6 +5,10 @@ get_program_persistable_vars
 
 .. py:function:: paddle.fluid.io.get_program_persistable_vars(program)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从Program中获取所有persistable的变量。
 
 参数:

doc/fluid/api_cn/io_cn/load_cn.rst

@@ -5,4 +5,11 @@ load
 
 .. py:function:: paddle.fluid.io.load(program, model_path, executor=None, var_list=None)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.load
+:alias: paddle.load,paddle.tensor.load,paddle.tensor.io.load
+:old_api: paddle.fluid.io.load
+
+
+
 ``fluid.io.load`` 是 :ref:`cn_api_fluid_load` 的别名

doc/fluid/api_cn/io_cn/load_inference_model_cn.rst

@@ -3,10 +3,13 @@
 load_inference_model
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 从指定文件路径中加载预测模型(Inference Model)，即调用该接口可获得模型结构（Inference Program）和模型参数。若只想加载预训练后的模型参数，请使用 :ref:`cn_api_fluid_io_load_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
 
 参数：

doc/fluid/api_cn/io_cn/load_params_cn.rst

@@ -3,10 +3,13 @@
 load_params
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从指定的 ``main_program`` 中筛选出所有模型参数变量，并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些模型参数进行赋值。
 
 使用 ``dirname`` 指定模型参数的存储路径。若模型参数变量以分离文件的形式存储在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有模型参数存储在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。

doc/fluid/api_cn/io_cn/load_persistables_cn.rst

@@ -3,10 +3,13 @@
 load_persistables
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从给定的 ``main_program`` 中取出所有 ``persistable==True`` 的变量（即持久性变量，详见 :ref:`api_guide_model_save_reader` ），并根据目录 ``dirname``  或 ``filename`` 提供的参数文件对这些持久性变量进行赋值。
 
 使用 ``dirname`` 指定持久性变量的存储路径。若持久性变量以分离文件的形式保存在 ``dirname`` 指定的目录下，则设置 ``filename`` 值为None；若所有持久性变量保存在一个单独的二进制文件中，则使用 ``filename`` 来指明这个二进制文件。

doc/fluid/api_cn/io_cn/load_program_state_cn.rst

@@ -5,6 +5,10 @@ load_program_state
 
 .. py:function:: paddle.fluid.io.load_program_state(model_path, var_list=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从本地加载 ``Program`` 的参数和优化器的变量信息到内存中。
 
 参数:

doc/fluid/api_cn/io_cn/load_vars_cn.rst

@@ -5,6 +5,10 @@ load_vars
 
 .. py:function:: paddle.fluid.io.load_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口从文件中加载 ``Program`` 的变量。
 
 通过 ``vars`` 指定需要加载的变量，或者通过 ``predicate`` 筛选需要加载的变量， ``vars`` 和 ``predicate`` 不能同时为None。

doc/fluid/api_cn/io_cn/map_readers_cn.rst

@@ -5,6 +5,9 @@ map_readers
 
 .. py:function::   paddle.fluid.io.map_readers(func, *readers)
 
+
+
+
 该接口将创建一个数据读取器(Reader)，其中 `func` 函数的输出将直接作为新数据读取器的输出， `readers` 的输出将作为函数 `func` 的输入参数。
 
 例如：如果输入的 `readers` 为两个输出分别为：2、3 的 `reader` ，输入的 `func` 为乘法函数 `mul(x, y)` ，则得到的新建 `reader` 的输出为：6。

doc/fluid/api_cn/io_cn/multiprocess_reader_cn.rst

@@ -5,6 +5,9 @@ multiprocess_reader
 
 .. py:function:: paddle.fluid.io.multiprocess_reader(readers, use_pipe=True, queue_size=1000)
 
+
+
+
 使用python多进程从 ``readers`` 中读取数据，然后使用 ``multiprocessing.Pipe`` 或 ``multiprocessing.Queue`` 合并所有数据。 ``readers`` 列表中的每个reader会被创建一个独立的进程来调用，reader之间应该相互独立，互不影响，避免出现多进程读取的冲突问题.
 
 multiprocess.queue需要/dev/shm的rw访问权限，某些平台不支持。

doc/fluid/api_cn/io_cn/save_cn.rst

@@ -3,8 +3,11 @@
 save
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.save(program, model_path)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 ``fluid.io.save`` 是 :ref:`cn_api_fluid_save` 的别名

doc/fluid/api_cn/io_cn/save_inference_model_cn.rst

@@ -3,10 +3,13 @@
 save_inference_model
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True,  program_only=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 修剪指定的 ``main_program`` 以构建一个专门用于预测的 ``Inference Program`` （ ``Program`` 含义详见 :ref:`api_guide_Program` ）。 所得到的 ``Inference Program`` 及其对应的所有相关参数均被保存到 ``dirname`` 指定的目录中。若只想保存训练后的模型参数，请使用 :ref:`cn_api_fluid_io_save_params` 接口。更多细节请参考 :ref:`api_guide_model_save_reader` 。
 
 **注意：dirname用于指定保存预测模型结构和参数的目录。若需要将模型参数保存在指定目录的若干文件中，请设置params_filename的值为None; 若需要将所有模型参数保存在一个单独的二进制文件中，请使用params_filename来指定该二进制文件的名称。**

doc/fluid/api_cn/io_cn/save_params_cn.rst

@@ -3,10 +3,13 @@
 save_params
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP从 ``main_program`` 中取出所有参数，然后将它们保存到 ``dirname`` 目录下或名为 ``filename`` 的文件中。
 
 ``dirname`` 用于指定保存参数的目标路径。若想将参数保存到多个独立文件中，设置 ``filename=None`` ； 若想将所有参数保存在单个文件中，请设置 ``filename`` 来指定该文件的名称。

doc/fluid/api_cn/io_cn/save_persistables_cn.rst

@@ -3,10 +3,13 @@
 save_persistables
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP从给定 ``main_program`` 中取出所有持久性变量（详见 :ref:`api_guide_model_save_reader` ），然后将它们保存到目录 ``dirname`` 中或 ``filename`` 指定的文件中。
 
 ``dirname`` 用于指定保存持久性变量的目录。如果想将持久性变量保存到指定目录的若干文件中，请设置 ``filename=None`` ; 若想将所有持久性变量保存在同一个文件中，请设置 ``filename`` 来指定文件的名称。

doc/fluid/api_cn/io_cn/save_vars_cn.rst

@@ -3,10 +3,13 @@
 save_vars
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口将 ``Program`` 的变量保存到文件中。
 
 通过 ``vars`` 指定需要保存的变量，或者通过 ``predicate`` 筛选需要保存的变量， ``vars`` 和 ``predicate`` 不能同时为None。

doc/fluid/api_cn/io_cn/set_program_state_cn.rst

@@ -5,6 +5,10 @@ set_program_state
 
 .. py:function:: paddle.fluid.io.set_program_state(program, state_dict)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 利用 ``state_dict`` 设置 ``Program`` 的参数和优化器信息。
 
 如果参数的 shape 或 dtype 不匹配，则会引发异常。

doc/fluid/api_cn/io_cn/shuffle_cn.rst

@@ -5,6 +5,12 @@ shuffle
 
 .. py:function:: paddle.fluid.io.shuffle(reader, buffer_size)
 
+:alias_main: paddle.shuffle
+:alias: paddle.shuffle,paddle.tensor.shuffle,paddle.tensor.random.shuffle
+:old_api: paddle.fluid.io.shuffle
+
+
+
 该接口创建一个数据读取器，其功能是将原始数据读取器的数据打乱，然后返回无序的数据。
 
 从原始数据读取器取出buf_size个数据到缓冲区，将缓冲区数据打乱，然后将无序的数据依次返回。当缓冲区数据全部输出后，再次执行上述步骤。

doc/fluid/api_cn/io_cn/xmap_readers_cn.rst

@@ -5,6 +5,9 @@ xmap_readers
 
 .. py:function:: paddle.fluid.io.xmap_readers(mapper, reader, process_num, buffer_size, order=False)
 
+
+
+
 多线程下，使用自定义映射器 reader 返回样本到输出队列。
 
 参数：

doc/fluid/api_cn/layers_cn/BeamSearchDecoder_cn.rst

@@ -4,10 +4,13 @@ BeamSearchDecoder
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.BeamSearchDecoder(cell, start_token, end_token, beam_size, embedding_fn=None, output_fn=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+    
 带beam search解码策略的解码器。该接口包装一个cell来计算概率，然后执行一个beam search步骤计算得分，并为每个解码步骤选择候选输出。更多详细信息请参阅 `Beam search <https://en.wikipedia.org/wiki/Beam_search>`_
     
 **注意** 在使用beam search解码时，cell的输入和状态将被扩展到 :math:`beam\_size` ，得到 :math:`[batch\_size * beam\_size, ...]` 一样的形状，这个操作在BeamSearchDecoder中自动完成，因此，其他任何在 :code:`cell.call` 中使用的tensor，如果形状为  :math:`[batch\_size, ...]` ，都必须先手动使用 :code:`BeamSearchDecoder.tile_beam_merge_with_batch` 接口扩展。最常见的情况是带注意机制的编码器输出。

doc/fluid/api_cn/layers_cn/Categorical_cn.rst

@@ -5,6 +5,9 @@ Categorical
 
 .. py:class:: paddle.fluid.layers.Categorical(logits)
 
+
+
+
 类别分布是一种离散概率分布，其随机变量可以取K个相互独立类别的其中一个。
 
 概率质量函数（pmf）为：

doc/fluid/api_cn/layers_cn/Decoder_cn.rst

@@ -4,10 +4,13 @@ Decoder
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.Decoder()
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
     
 Decoder是dynamic_decode中使用的任何decoder实例的基类。它提供了为每一个时间步生成输出的接口，可用于生成序列。
 

doc/fluid/api_cn/layers_cn/DynamicRNN_cn.rst

@@ -3,10 +3,13 @@
 DynamicRNN
 ===================
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.DynamicRNN(name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该类型的输入仅支持LoDTensor，如果您需要处理的输入数据是Tensor类型，
 请使用StaticRNN（ fluid.layers.** :ref:`cn_api_fluid_layers_StaticRNN` **)。**
 

doc/fluid/api_cn/layers_cn/GRUCell_cn.rst

@@ -3,10 +3,13 @@
 GRUCell
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.GRUCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, dtype="float32", name="GRUCell")
 
+:api_attr: 声明式编程模式（静态图)
+
+
+    
 门控循环单元（Gated Recurrent Unit）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicGRUUnit` 包装，来让它可以应用于RNNCell。
 
 公式如下：

doc/fluid/api_cn/layers_cn/IfElse_cn.rst

@@ -3,10 +3,13 @@
 IfElse
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.IfElse(cond, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该类用于实现IfElse分支控制功能， IfElse包含两个Block，true_block，false_block，IfElse会将满足True或False条件的数据分别放入不同的block运行。    
 
 cond是一个shape为[N, 1]、数据类型为bool的2-D tensor，表示输入数据对应部分的执行条件。

doc/fluid/api_cn/layers_cn/LSTMCell_cn.rst

@@ -4,10 +4,13 @@ LSTMCell
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.LSTMCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, forget_bias=1.0, dtype="float32", name="LSTMCell")
 
+:api_attr: 声明式编程模式（静态图)
+
+
+    
 长短期记忆单元（Long-Short Term Memory）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicLSTMUnit` 包装，来让它可以应用于RNNCell。    
 
 公式如下：

doc/fluid/api_cn/layers_cn/MultivariateNormalDiag_cn.rst

@@ -5,6 +5,9 @@ MultivariateNormalDiag
 
 .. py:class:: paddle.fluid.layers.MultivariateNormalDiag(loc, scale)
 
+
+
+
 多元高斯分布
 
 概率密度函数（pdf）为：

doc/fluid/api_cn/layers_cn/Normal_cn.rst

@@ -5,6 +5,9 @@ Normal
 
 .. py:class:: paddle.fluid.layers.Normal(loc, scale)
 
+
+
+
 正态分布
 
 数学公式：

doc/fluid/api_cn/layers_cn/Print_cn.rst

@@ -3,10 +3,13 @@
 Print
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.Print(input, first_n=-1, message=None, summarize=20, print_tensor_name=True, print_tensor_type=True, print_tensor_shape=True, print_tensor_lod=True, print_phase='both')
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **Print操作命令**
 
 该OP创建一个打印操作，打印正在访问的Tensor内容。

doc/fluid/api_cn/layers_cn/RNNCell_cn.rst

@@ -4,9 +4,12 @@ RNNCell
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.RNNCell(name=None)
+
+:api_attr: 声明式编程模式（静态图)
+
+
 RNNCell是抽象的基类，代表将输入和状态映射到输出和新状态的计算，主要用于RNN。
 
 .. py:method:: call(inputs, states, **kwargs)

doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst

@@ -3,10 +3,13 @@
 StaticRNN
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.StaticRNN(name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP用来处理一批序列数据，其中每个样本序列的长度必须相等。StaticRNN将序列按照时间步长展开，用户需要定义每个时间步中的处理逻辑。
 
 参数：

doc/fluid/api_cn/layers_cn/Switch_cn.rst

@@ -3,10 +3,13 @@
 Switch
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.Switch (name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该类用于实现Switch分支控制功能。Switch分支包含多个case分支和一个default分支，Switch控制流会依次检查各case分支条件是否满足，并仅执行第一个满足条件的case分支后面的语句。若不存在满足条件的case分支，则仅执行default分支后面的语句。
 
 .. note::

doc/fluid/api_cn/layers_cn/Uniform_cn.rst

@@ -5,6 +5,9 @@ Uniform
 
 .. py:class:: paddle.fluid.layers.Uniform(low, high)
 
+
+
+
 均匀分布
 
 概率密度函数（pdf）为：

doc/fluid/api_cn/layers_cn/While_cn.rst

@@ -3,10 +3,13 @@
 While
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.layers.While (cond, is_test=False, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 该类用于实现while循环控制功能，只要循环条件cond为True，就循环执行while循环体中的语句，直到cond为False为止。
 

doc/fluid/api_cn/layers_cn/abs_cn.rst

@@ -5,6 +5,12 @@ abs
 
 .. py:function:: paddle.fluid.layers.abs(x, name=None)
 
+:alias_main: paddle.abs
+:alias: paddle.abs,paddle.tensor.abs,paddle.tensor.math.abs
+:old_api: paddle.fluid.layers.abs
+
+
+
 绝对值激活函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/accuracy_cn.rst

@@ -5,6 +5,9 @@ accuracy
 
 .. py:function:: paddle.fluid.layers.accuracy(input, label, k=1, correct=None, total=None)
 
+
+
+
 accuracy layer。 参考 https://en.wikipedia.org/wiki/Precision_and_recall
 
 使用输入和标签计算准确率。 如果正确的标签在topk个预测值里，则计算结果加1。注意：输出正确率的类型由input类型决定，input和lable的类型可以不一样。

doc/fluid/api_cn/layers_cn/acos_cn.rst

@@ -5,6 +5,12 @@ acos
 
 .. py:function:: paddle.fluid.layers.acos(x, name=None)
 
+:alias_main: paddle.acos
+:alias: paddle.acos,paddle.tensor.acos,paddle.tensor.math.acos
+:old_api: paddle.fluid.layers.acos
+
+
+
 arccosine激活函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/adaptive_pool2d_cn.rst

@@ -5,6 +5,12 @@ adaptive_pool2d
 
 .. py:function:: paddle.fluid.layers.adaptive_pool2d(input, pool_size, pool_type='max', require_index=False, name=None)
 
+:alias_main: paddle.nn.functional.adaptive_pool2d
+:alias: paddle.nn.functional.adaptive_pool2d,paddle.nn.functional.pooling.adaptive_pool2d
+:old_api: paddle.fluid.layers.adaptive_pool2d
+
+
+
 该OP使用上述输入参数的池化配置，为二维空间自适应池化操作，根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核大小 ``pool_size`` 这些参数得到输出。
 
 输入X和输出Out是NCHW格式，N为批大小，C是通道数，H是特征高度，W是特征宽度。参数 ``pool_size`` 含有两个整型元素, 分别代表高度和宽度上的参数。输出Out的H和W维由 ``pool_size`` 决定，即输出shape为 :math:`\left ( N,C,pool_size[0],pool_size[1] \right )`

doc/fluid/api_cn/layers_cn/adaptive_pool3d_cn.rst

@@ -5,6 +5,12 @@ adaptive_pool3d
 
 .. py:function:: paddle.fluid.layers.adaptive_pool3d(input, pool_size, pool_type='max', require_index=False, name=None)
 
+:alias_main: paddle.nn.functional.adaptive_pool3d
+:alias: paddle.nn.functional.adaptive_pool3d,paddle.nn.functional.pooling.adaptive_pool3d
+:old_api: paddle.fluid.layers.adaptive_pool3d
+
+
+
 该OP使用上述输入参数的池化配置，为二维空间自适应池化操作，根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核大小 ``pool_size`` 这些参数得到输出。
 
 输入X和输出Out是NCDHW格式，N为批大小，D是特征深度，C是通道数，H是特征高度，W是特征宽度。参数 ``pool_size`` 含有两个整型元素, 分别代表深度，高度和宽度上的参数。输出Out的D, H和W维由 ``pool_size`` 决定，即输出shape为 :math:`\left ( N,C,pool_size[0],pool_size[1],pool_size[2] \right )`

doc/fluid/api_cn/layers_cn/add_position_encoding_cn.rst

@@ -5,6 +5,12 @@ add_position_encoding
 
 .. py:function:: paddle.fluid.layers.add_position_encoding(input, alpha, beta, name=None)
 
+:alias_main: paddle.nn.functional.add_position_encoding
+:alias: paddle.nn.functional.add_position_encoding,paddle.nn.functional.extension.add_position_encoding
+:old_api: paddle.fluid.layers.add_position_encoding
+
+
+
 该OP将输入inpu中每个位置（序列中的位置）的特征与对应的位置编码加权求和，位置编码可参考论文: `Attention Is All You Need <http://arxiv.org/pdf/1706.03762.pdf>`_
 
 输出的计算公式如下：

doc/fluid/api_cn/layers_cn/affine_channel_cn.rst

@@ -5,6 +5,12 @@ affine_channel
 
 .. py:function:: paddle.fluid.layers.affine_channel(x, scale=None, bias=None, data_layout='NCHW', name=None,act=None)
 
+:alias_main: paddle.nn.functional.affine_channel
+:alias: paddle.nn.functional.affine_channel,paddle.nn.functional.vision.affine_channel
+:old_api: paddle.fluid.layers.affine_channel
+
+
+
 对输入的每个 channel 应用单独的仿射变换。用于将空间批量归一化替换为其等价的固定变换。
 
 输入也可以是二维张量，并在第二维应用仿射变换。

doc/fluid/api_cn/layers_cn/affine_grid_cn.rst

@@ -5,6 +5,12 @@ affine_grid
 
 .. py:function:: paddle.fluid.layers.affine_grid(theta, out_shape, name=None)
 
+:alias_main: paddle.nn.functional.affine_grid
+:alias: paddle.nn.functional.affine_grid,paddle.nn.functional.vision.affine_grid
+:old_api: paddle.fluid.layers.affine_grid
+
+
+
 该OP用于生成仿射变换前后的feature maps的坐标映射关系。在视觉应用中，根据该OP得到的映射关系，将输入feature map的像素点变换到对应的坐标，就得到了经过仿射变换的feature map。
 
 参数：

doc/fluid/api_cn/layers_cn/anchor_generator_cn.rst

@@ -5,6 +5,12 @@ anchor_generator
 
 .. py:function:: paddle.fluid.layers.anchor_generator(input, anchor_sizes=None, aspect_ratios=None, variance=[0.1, 0.1, 0.2, 0.2], stride=None, offset=0.5, name=None)
 
+:alias_main: paddle.nn.functional.anchor_generator
+:alias: paddle.nn.functional.anchor_generator,paddle.nn.functional.vision.anchor_generator
+:old_api: paddle.fluid.layers.anchor_generator
+
+
+
 **Anchor generator operator**
 
 为RCNN算法生成anchor，输入的每一位产生N个anchor，N=size(anchor_sizes)*size(aspect_ratios)。生成anchor的顺序首先是aspect_ratios循环，然后是anchor_sizes循环。

doc/fluid/api_cn/layers_cn/argmax_cn.rst

@@ -5,6 +5,9 @@ argmax
 
 .. py:function:: paddle.fluid.layers.argmax(x, axis=0)
 
+
+
+
 **argmax**
 
 该OP沿 ``axis`` 计算输入 ``x`` 的最大元素的索引。

doc/fluid/api_cn/layers_cn/argmin_cn.rst

@@ -5,6 +5,12 @@ argmin
 
 .. py:function:: paddle.fluid.layers.argmin(x, axis=0)
 
+:alias_main: paddle.argmin
+:alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin
+:old_api: paddle.fluid.layers.argmin
+
+
+
 **argmin**
 
 该OP沿 ``axis`` 计算输入 ``x`` 的最小元素的索引。

doc/fluid/api_cn/layers_cn/argsort_cn.rst

@@ -5,6 +5,12 @@ argsort
 
 .. py:function:: paddle.fluid.layers.argsort(input,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`` 。
 
 

doc/fluid/api_cn/layers_cn/array_length_cn.rst

@@ -5,6 +5,9 @@ array_length
 
 .. py:function:: paddle.fluid.layers.array_length(array)
 
+
+
+
 该OP用于获取输入数组 :ref:`cn_api_fluid_LoDTensorArray` 的长度。可以与 :ref:`cn_api_fluid_layers_array_read` 、 :ref:`cn_api_fluid_layers_array_write` 、 :ref:`cn_api_fluid_layers_While` OP结合使用，实现LoDTensorArray的遍历与读写。
 
 参数：

doc/fluid/api_cn/layers_cn/array_read_cn.rst

@@ -5,6 +5,9 @@ array_read
 
 .. py:function:: paddle.fluid.layers.array_read(array,i)
 
+
+
+
 该OP用于读取输入数组 :ref:`cn_api_fluid_LoDTensorArray` 中指定位置的数据, ``array`` 为输入的数组， ``i`` 为指定的读取位置。常与 :ref:`cn_api_fluid_layers_array_write` OP配合使用进行LoDTensorArray的读写。
 
 例1:

doc/fluid/api_cn/layers_cn/array_write_cn.rst

@@ -5,6 +5,9 @@ array_write
 
 .. py:function:: paddle.fluid.layers.array_write(x, i, array=None)
 
+
+
+
 该OP将输入的变量 ``x`` 写入到数组 :ref:`cn_api_fluid_LoDTensorArray` ``array`` 的第i个位置，并返回修改后的LoDTensorArray，如果 ``array`` 为None，则创建一个新的LoDTensorArray。常与 :ref:`cn_api_fluid_layers_array_read` OP联合使用对LoDTensorArray进行读写。
 
 参数:

doc/fluid/api_cn/layers_cn/asin_cn.rst

@@ -5,6 +5,12 @@ asin
 
 .. py:function:: paddle.fluid.layers.asin(x, name=None)
 
+:alias_main: paddle.asin
+:alias: paddle.asin,paddle.tensor.asin,paddle.tensor.math.asin
+:old_api: paddle.fluid.layers.asin
+
+
+
 arcsine激活函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/assign_cn.rst

@@ -5,6 +5,12 @@ assign
 
 .. py:function:: paddle.fluid.layers.assign(input,output=None)
 
+:alias_main: paddle.nn.functional.assign
+:alias: paddle.nn.functional.assign,paddle.nn.functional.common.assign
+:old_api: paddle.fluid.layers.assign
+
+
+
 该OP将输入Tensor或numpy数组拷贝至输出Tensor。
 
 参数：

doc/fluid/api_cn/layers_cn/atan_cn.rst

@@ -5,6 +5,12 @@ atan
 
 .. py:function:: paddle.fluid.layers.atan(x, name=None)
 
+:alias_main: paddle.atan
+:alias: paddle.atan,paddle.tensor.atan,paddle.tensor.math.atan
+:update_api: paddle.fluid.layers.atan
+
+
+
 arctanh激活函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/auc_cn.rst

@@ -5,6 +5,9 @@ auc
 
 .. py:function:: paddle.fluid.layers.auc(input, label, curve='ROC', num_thresholds=200, topk=1, slide_steps=1)
 
+
+
+
 **Area Under the Curve(AUC) Layer**
 
 该层根据前向输出和标签计算AUC，在二分类(binary classification)估计中广泛使用。

doc/fluid/api_cn/layers_cn/autoincreased_step_counter_cn.rst

@@ -3,10 +3,13 @@
 autoincreased_step_counter
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.autoincreased_step_counter(counter_name=None, begin=1, step=1)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 创建一个自增变量，每个迭代累加一次，默认首次返回值为 1，默认累加步长为 1。
 
 参数：

doc/fluid/api_cn/layers_cn/batch_norm_cn.rst

@@ -3,10 +3,13 @@
 batch_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.batch_norm(input, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 批正则化层（Batch Normalization Layer）
 
 可用作卷积和全连接操作的批正则化函数，根据当前批次数据按通道计算的均值和方差进行正则化。该层需要的数据格式如下：

doc/fluid/api_cn/layers_cn/beam_search_cn.rst

@@ -5,6 +5,12 @@ beam_search
 
 .. py:function:: paddle.fluid.layers.beam_search(pre_ids, pre_scores, ids, scores, beam_size, end_id, level=0, is_accumulated=True, name=None, return_parent_idx=False)
 
+:alias_main: paddle.nn.beam_search
+:alias: paddle.nn.beam_search,paddle.nn.decode.beam_search
+:old_api: paddle.fluid.layers.beam_search
+
+
+
 束搜索(Beam search)是在机器翻译等生成任务中选择候选词的一种经典算法
 
 更多细节参考 `Beam Search <https://en.wikipedia.org/wiki/Beam_search>`_

doc/fluid/api_cn/layers_cn/beam_search_decode_cn.rst

@@ -5,6 +5,12 @@ beam_search_decode
 
 .. py:function:: paddle.fluid.layers.beam_search_decode(ids, scores, beam_size, end_id, name=None)
 
+:alias_main: paddle.nn.beam_search_decode
+:alias: paddle.nn.beam_search_decode,paddle.nn.decode.beam_search_decode
+:old_api: paddle.fluid.layers.beam_search_decode
+
+
+
 该OP用在整个束搜索(Beam search)结束后，通过沿 ``ids`` 中保存的搜索路径回溯，为每个源句（样本）构造完整的beam search结果序列并保存在LoDTensor中。LoDTensor的格式和解析方式如下：
 
 ::

doc/fluid/api_cn/layers_cn/bilinear_tensor_product_cn.rst

@@ -3,10 +3,13 @@
 bilinear_tensor_product
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.bilinear_tensor_product(x, y, size, act=None, name=None, param_attr=None, bias_attr=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该层对两个输入执行双线性张量积。
 
 例如:

doc/fluid/api_cn/layers_cn/bipartite_match_cn.rst

@@ -5,6 +5,12 @@ bipartite_match
 
 .. py:function:: paddle.fluid.layers.bipartite_match(dist_matrix, match_type=None, dist_threshold=None, name=None)
 
+:alias_main: paddle.nn.functional.bipartite_match
+:alias: paddle.nn.functional.bipartite_match,paddle.nn.functional.vision.bipartite_match
+:old_api: paddle.fluid.layers.bipartite_match
+
+
+
 该OP实现了贪心二分匹配算法，该算法用于根据输入距离矩阵获得与最大距离的匹配。对于输入二维矩阵，二分匹配算法可以找到每一行的匹配列（匹配意味着最大距离），也可以找到每列的匹配行。此算子仅计算列到行的匹配索引。对于每个实例，匹配索引的数量是
 输入距离矩阵的列号。**该OP仅支持CPU**
 

doc/fluid/api_cn/layers_cn/box_clip_cn.rst

@@ -5,6 +5,12 @@ box_clip
 
 .. py:function:: paddle.fluid.layers.box_clip(input, im_info, name=None)
 
+:alias_main: paddle.nn.functional.box_clip
+:alias: paddle.nn.functional.box_clip,paddle.nn.functional.vision.box_clip
+:old_api: paddle.fluid.layers.box_clip
+
+
+
 将检测框框剪切为 ``im_info`` 给出的大小。对于每个输入框，公式如下：
 
 ::

doc/fluid/api_cn/layers_cn/box_coder_cn.rst

@@ -5,6 +5,12 @@ box_coder
 
 .. py:function:: paddle.fluid.layers.box_coder(prior_box, prior_box_var, target_box, code_type='encode_center_size', box_normalized=True, name=None, axis=0)
 
+:alias_main: paddle.nn.functional.box_coder
+:alias: paddle.nn.functional.box_coder,paddle.nn.functional.vision.box_coder
+:old_api: paddle.fluid.layers.box_coder
+
+
+
 Bounding Box Coder
 
 编码/解码带有先验框信息的目标边界框

doc/fluid/api_cn/layers_cn/box_decoder_and_assign_cn.rst

@@ -5,6 +5,12 @@ box_decoder_and_assign
 
 .. py:function:: paddle.fluid.layers.box_decoder_and_assign(prior_box, prior_box_var, target_box, box_score, box_clip, name=None)
 
+:alias_main: paddle.nn.functional.box_decoder_and_assign
+:alias: paddle.nn.functional.box_decoder_and_assign,paddle.nn.functional.vision.box_decoder_and_assign
+:old_api: paddle.fluid.layers.box_decoder_and_assign
+
+
+
 边界框编码器。
 
 根据先验框来解码目标边界框。

doc/fluid/api_cn/layers_cn/bpr_loss_cn.rst

@@ -5,6 +5,12 @@ bpr_loss
 
 .. py:function:: paddle.fluid.layers.bpr_loss(input, label, name=None)
 
+:alias_main: paddle.nn.functional.bpr_loss
+:alias: paddle.nn.functional.bpr_loss,paddle.nn.functional.loss.bpr_loss
+:old_api: paddle.fluid.layers.bpr_loss
+
+
+
 
 贝叶斯个性化排序损失函数（Bayesian Personalized Ranking Loss Operator ）
 

doc/fluid/api_cn/layers_cn/brelu_cn.rst

@@ -5,6 +5,12 @@ brelu
 
 .. py:function:: paddle.fluid.layers.brelu(x, t_min=0.0, t_max=24.0, name=None)
 
+:alias_main: paddle.nn.functional.brelu
+:alias: paddle.nn.functional.brelu,paddle.nn.functional.activation.brelu
+:old_api: paddle.fluid.layers.brelu
+
+
+
 
 BReLU 激活函数
 

doc/fluid/api_cn/layers_cn/case_cn.rst

@@ -3,10 +3,16 @@
 case
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.case(pred_fn_pairs, default=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.case
+:alias: paddle.nn.case,paddle.nn.control_flow.case
+:old_api: paddle.fluid.layers.case
+
+
+
 该OP的运行方式类似于python的if-elif-elif-else。
 
 参数：

doc/fluid/api_cn/layers_cn/cast_cn.rst

@@ -5,6 +5,12 @@ cast
 
 .. py:function:: paddle.fluid.layers.cast(x,dtype)
 
+:alias_main: paddle.cast
+:alias: paddle.cast,paddle.tensor.cast,paddle.tensor.manipulation.cast
+:old_api: paddle.fluid.layers.cast
+
+
+
 该OP将 ``x`` 的数据类型转换为 ``dtype`` 并输出。支持输出和输入的数据类型相同。
 
 参数：

doc/fluid/api_cn/layers_cn/ceil_cn.rst

@@ -5,6 +5,12 @@ ceil
 
 .. py:function:: paddle.fluid.layers.ceil(x, name=None)
 
+:alias_main: paddle.ceil
+:alias: paddle.ceil,paddle.tensor.ceil,paddle.tensor.math.ceil
+:old_api: paddle.fluid.layers.ceil
+
+
+
 向上取整运算函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/center_loss_cn.rst

@@ -3,10 +3,16 @@
 center_loss
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.center_loss(input, label, num_classes, alpha, param_attr, update_center=True)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.functional.center_loss
+:alias: paddle.nn.functional.center_loss,paddle.nn.functional.loss.center_loss
+:old_api: paddle.fluid.layers.center_loss
+
+
+
 该OP接收一个来自于最后一个隐藏层的输出和目标标签作为输入，返回损失值。为每一个类别提供一个类别中心，计算mini-batch中每个样本与对应类别中心的距离的平均值作为center loss。
 
 对于输入，\(X\)和标签\(Y\)，计算公式为：

doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst

@@ -5,6 +5,9 @@ chunk_eval
 
 .. py:function:: paddle.fluid.layers.chunk_eval(input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None, sqe_length=None)
 
+
+
+
 该OP计算语块识别（chunk detection）的准确率、召回率和F1值，常用于命名实体识别（NER，语块识别的一种）等序列标注任务中。
 
 语块识别的基础请参考 `Chunking with Support Vector Machines <https://www.aclweb.org/anthology/N01-1025>`_

doc/fluid/api_cn/layers_cn/clip_by_norm_cn.rst

@@ -5,6 +5,12 @@ clip_by_norm
 
 .. py:function:: paddle.fluid.layers.clip_by_norm(x, max_norm, name=None)
 
+:alias_main: paddle.nn.clip_by_norm
+:alias: paddle.nn.clip_by_norm,paddle.nn.clip.clip_by_norm
+:old_api: paddle.fluid.layers.clip_by_norm
+
+
+
 ClipByNorm算子
 
 此算子将输入 ``X`` 的L2范数限制在 ``max_norm`` 内。如果 ``X`` 的L2范数小于或等于 ``max_norm``  ，则输出（Out）将与 ``X`` 相同。如果X的L2范数大于 ``max_norm`` ，则 ``X`` 将被线性缩放，使得输出（Out）的L2范数等于 ``max_norm`` ，如下面的公式所示：

doc/fluid/api_cn/layers_cn/clip_cn.rst

@@ -5,6 +5,12 @@ clip
 
 .. py:function:: paddle.fluid.layers.clip(x, min, max, name=None)
 
+:alias_main: paddle.nn.clip
+:alias: paddle.nn.clip,paddle.nn.clip.clip
+:old_api: paddle.fluid.layers.clip
+
+
+
 该OP对输入Tensor每个元素的数值进行裁剪，使得输出Tensor元素的数值被限制在区间[min, max]内。具体的计算公式为如下。
 
 .. math::

doc/fluid/api_cn/layers_cn/collect_fpn_proposals_cn.rst

@@ -5,6 +5,12 @@ collect_fpn_proposals
 
 .. py:function:: paddle.fluid.layers.collect_fpn_proposals(multi_rois, multi_scores, min_level, max_level, post_nms_top_n, name=None)
 
+:alias_main: paddle.nn.functional.collect_fpn_proposals
+:alias: paddle.nn.functional.collect_fpn_proposals,paddle.nn.functional.vision.collect_fpn_proposals
+:old_api: paddle.fluid.layers.collect_fpn_proposals
+
+
+
 **该op仅支持LoDTensor输入**。连接多级RoIs（感兴趣区域）并依据multi_scores选择N个RoIs。此操作执行以下步骤：
 1、选择num_level个RoIs和scores作为输入：num_level = max_level - min_level
 2、连接num_level个RoIs和scores。

doc/fluid/api_cn/layers_cn/concat_cn.rst

@@ -5,6 +5,12 @@ concat
 
 .. py:function:: paddle.fluid.layers.concat(input,axis=0,name=None)
 
+:alias_main: paddle.concat
+:alias: paddle.concat,paddle.tensor.concat,paddle.tensor.manipulation.concat
+:old_api: paddle.fluid.layers.concat
+
+
+
 该OP对输入沿 ``axis`` 轴进行联结。
 
 参数：

doc/fluid/api_cn/layers_cn/cond_cn.rst

@@ -3,10 +3,16 @@
 cond
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.cond(pred, true_fn=None, false_fn=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.cond
+:alias: paddle.nn.cond,paddle.nn.control_flow.cond
+:old_api: paddle.fluid.layers.cond
+
+
+
 如果 ``pred`` 是 ``True`` ，该API返回 ``true_fn()`` ，否则返回 ``false_fn()`` 。
 用户如果不想在 ``callable`` 中做任何事，可以把 ``true_fn`` 或 ``false_fn`` 设为 ``None`` ，此时本API会把该 ``callable`` 视为简单返回 ``None`` 。
 

doc/fluid/api_cn/layers_cn/continuous_value_model_cn.rst

@@ -5,6 +5,12 @@ continuous_value_model
 
 .. py:function:: paddle.fluid.layers.continuous_value_model(input, cvm, use_cvm=True)
 
+:alias_main: paddle.nn.functional.continuous_value_model
+:alias: paddle.nn.functional.continuous_value_model,paddle.nn.functional.extension.continuous_value_model
+:old_api: paddle.fluid.layers.continuous_value_model
+
+
+
 **注意：该OP仅支持在CPU运行。**
 
 该OP在CTR项目中，用于去除或处理 ``input`` 中的展示和点击值。

doc/fluid/api_cn/layers_cn/conv2d_cn.rst

@@ -3,10 +3,13 @@
 conv2d
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.conv2d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCHW")
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP是二维卷积层（convolution2D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。
 
 对每个输入X，有等式：

doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst

@@ -3,10 +3,13 @@
 conv2d_transpose
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.conv2d_transpose(input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format='NCHW')
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 二维转置卷积层（Convlution2D transpose layer）
 
 该层根据输入（input）、滤波器（filter）和卷积核膨胀比例（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCHW或NHWC格式，其中N为批尺寸，C为通道数（channel），H为特征层高度，W为特征层宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数大于1，C等于输入图像通道数除以组数的结果。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解转置卷积层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。如果act不为None，则转置卷积计算之后添加相应的激活函数。

doc/fluid/api_cn/layers_cn/conv3d_cn.rst

@@ -3,10 +3,13 @@
 conv3d
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.conv3d(input, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCDHW")
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP是三维卷积层（convolution3D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算得到输出特征层大小。输入和输出是NCDHW或NDWHC格式，其中N是批尺寸，C是通道数，D是特征层深度，H是特征层高度，W是特征层宽度。三维卷积（Convlution3D）和二维卷积（Convlution2D）相似，但多了一维深度信息（depth）。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。
 
 对每个输入X，有等式：

doc/fluid/api_cn/layers_cn/conv3d_transpose_cn.rst

@@ -3,10 +3,13 @@
 conv3d_transpose
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.conv3d_transpose(input, num_filters, output_size=None, filter_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format='NCDHW')
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 三维转置卷积层（Convlution3D transpose layer)
 
 该层根据输入（input）、滤波器（filter）和卷积核膨胀比例（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCDHW或者NDHWC格式。其中N为批尺寸，C为通道数（channel），D为特征深度，H为特征层高度，W为特征层宽度。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解卷积转置层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。如果act不为None，则转置卷积计算之后添加相应的激活函数。

doc/fluid/api_cn/layers_cn/cos_cn.rst

@@ -5,6 +5,12 @@ cos
 
 .. py:function:: paddle.fluid.layers.cos(x, name=None)
 
+:alias_main: paddle.cos
+:alias: paddle.cos,paddle.tensor.cos,paddle.tensor.math.cos
+:old_api: paddle.fluid.layers.cos
+
+
+
 余弦函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/cos_sim_cn.rst

@@ -5,6 +5,9 @@ cos_sim
 
 .. py:function:: paddle.fluid.layers.cos_sim(X, Y)
 
+
+
+
 余弦相似度算子（Cosine Similarity Operator）
 
 .. math::

doc/fluid/api_cn/layers_cn/cosine_decay_cn.rst

@@ -5,6 +5,12 @@ cosine_decay
 
 .. py:function:: paddle.fluid.layers.cosine_decay(learning_rate, step_each_epoch, epochs)
 
+:alias_main: paddle.nn.functional.cosine_decay
+:alias: paddle.nn.functional.cosine_decay,paddle.nn.functional.learning_rate.cosine_decay
+:old_api: paddle.fluid.layers.cosine_decay
+
+
+
 使用 cosine decay 的衰减方式进行学习率调整。
 
 在训练模型时，建议一边进行训练一边降低学习率。 通过使用此方法，学习速率将通过如下cosine衰减策略进行衰减：

doc/fluid/api_cn/layers_cn/create_array_cn.rst

@@ -6,6 +6,9 @@ create_array
 .. py:function:: paddle.fluid.layers.create_array(dtype)
 
 
+
+
+
 此OP创建一个LoDTensorArray，它可以用作 :ref:`cn_api_fluid_layers_array\_write` , :ref:`cn_api_fluid_layers_array\_read` OP的输入，以及和 :ref:`cn_api_fluid_layers_While` OP
 一起创建RNN网络。
 

doc/fluid/api_cn/layers_cn/create_global_var_cn.rst

@@ -5,6 +5,9 @@ create_global_var
 
 .. py:function:: paddle.fluid.layers.create_global_var(shape,value,dtype,persistable=False,force_cpu=False,name=None)
 
+
+
+
 该OP在全局块中创建一个新的Tensor，Tensor的值为 ``value`` 。
 
 参数：

doc/fluid/api_cn/layers_cn/create_parameter_cn.rst

@@ -3,10 +3,13 @@
 create_parameter
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.create_parameter(shape,dtype,name=None,attr=None,is_bias=False,default_initializer=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP创建一个参数。该参数是一个可学习的变量, 拥有梯度并且可优化。
 
 **注意：这是一个低级别的API。如果您希望自己创建新的op，这个API将非常有用，无需使用layers。**

doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst

@@ -3,10 +3,13 @@
 create_py_reader_by_data
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.create_py_reader_by_data(capacity,feed_list,name=None,use_double_buffer=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 创建一个Python端提供数据的reader。该OP与 :ref:`cn_api_fluid_layers_py_reader` 类似，不同点在于它能够从feed变量列表读取数据。
 
 参数：

doc/fluid/api_cn/layers_cn/create_tensor_cn.rst

@@ -5,6 +5,12 @@ create_tensor
 
 .. py:function:: paddle.fluid.layers.create_tensor(dtype,name=None,persistable=False)
 
+:alias_main: paddle.create_tensor
+:alias: paddle.create_tensor,paddle.tensor.create_tensor,paddle.tensor.creation.create_tensor
+:old_api: paddle.fluid.layers.create_tensor
+
+
+
 创建数据类型为dtype的Tensor。
 
 参数：

doc/fluid/api_cn/layers_cn/crf_decoding_cn.rst

@@ -3,10 +3,13 @@
 crf_decoding
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.crf_decoding(input, param_attr, label=None, length=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 
 该层读取由 :ref:`cn_api_fluid_layers_linear_chain_crf` 学习的 emission feature weights（发射状态特征的权重）和 transition feature weights (转移特征的权重) 进行解码。

doc/fluid/api_cn/layers_cn/crop_cn.rst

@@ -5,6 +5,9 @@ crop
 
 .. py:function:: paddle.fluid.layers.crop(x, shape=None, offsets=None, name=None)
 
+
+
+
 该OP根据偏移量(offsets)和形状(shape)，裁剪输入张量。
 
 **注意:** 此OP已被弃用，它将在以后的版本中被删除，请使用 :ref:`cn_api_fluid_layers_crop_tensor` 替代

doc/fluid/api_cn/layers_cn/crop_tensor_cn.rst

@@ -5,6 +5,12 @@ crop_tensor
 
 .. py:function:: paddle.fluid.layers.crop_tensor(x, shape=None, offsets=None, name=None)
 
+:alias_main: paddle.crop_tensor
+:alias: paddle.crop_tensor,paddle.tensor.crop_tensor,paddle.tensor.creation.crop_tensor
+:old_api: paddle.fluid.layers.crop_tensor
+
+
+
 根据偏移量（offsets）和形状（shape），裁剪输入（x）Tensor。
 
 **示例**：

doc/fluid/api_cn/layers_cn/cross_entropy_cn.rst

@@ -5,6 +5,12 @@ cross_entropy
 
 .. py:function:: paddle.fluid.layers.cross_entropy(input, label, soft_label=False, ignore_index=-100)
 
+:alias_main: paddle.nn.functional.cross_entropy
+:alias: paddle.nn.functional.cross_entropy,paddle.nn.functional.loss.cross_entropy
+:old_api: paddle.fluid.layers.cross_entropy
+
+
+
 该OP计算输入input和标签label间的交叉熵，可用于计算硬标签或软标签的交叉熵。
 
 1. 硬标签交叉熵算法：若soft_label = False, :math:`label[i_1, i_2, ..., i_k]` 表示每个样本的硬标签值:

doc/fluid/api_cn/layers_cn/ctc_greedy_decoder_cn.rst

@@ -6,6 +6,9 @@ ctc_greedy_decoder
 .. py:function:: paddle.fluid.layers.ctc_greedy_decoder(input, blank, name=None)
 
 
+
+
+
 该OP用于贪婪策略解码序列，步骤如下:
     1. 获取输入中的每一行的最大值索引，也就是numpy.argmax(input, axis=0)。
     2. 对于step1结果中的每个序列，合并两个空格之间的重复部分并删除所有空格。

doc/fluid/api_cn/layers_cn/cumsum_cn.rst

@@ -5,6 +5,12 @@ cumsum
 
 .. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=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。
 
 参数：

doc/fluid/api_cn/layers_cn/data_cn.rst

@@ -3,10 +3,12 @@
 data
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.data(name, shape, append_batch_size=True, dtype='float32', lod_level=0, type=VarType.LOD_TENSOR, stop_gradient=True)
 
+
+
+
 该OP会在全局block中创建变量（Variable），该全局变量可被计算图中的算子（operator）访问。
 
 注意：

doc/fluid/api_cn/layers_cn/data_norm_cn.rst

@@ -3,10 +3,13 @@
 data_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.data_norm(input, act=None, epsilon=1e-05, param_attr=None, data_layout='NCHW', in_place=False, name=None, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **数据正则化层**
 
 可用作conv2d和fully_connected操作的正则化函数。 此层所需的数据格式为以下之一：

doc/fluid/api_cn/layers_cn/deformable_conv_cn.rst

@@ -3,10 +3,13 @@
 deformable_conv
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.deformable_conv(input, offset, mask, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, deformable_groups=None, im2col_step=None, param_attr=None, bias_attr=None, modulated=True, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **可变形卷积算子**
 
 deformable_conv op对输入4-D Tensor计算2-D可变形卷积。给定输入Tensor x，输出Tensor y，可变形卷积运算如下所示：

doc/fluid/api_cn/layers_cn/deformable_roi_pooling_cn.rst

@@ -5,6 +5,12 @@ deformable_roi_pooling
 
 .. py:function:: paddle.fluid.layers.deformable_roi_pooling(input, rois, trans, no_trans=False, spatial_scale=1.0, group_size=[1, 1], pooled_height=1, pooled_width=1, part_size=None, sample_per_part=1, trans_std=0.1, position_sensitive=False, name=None)
 
+:alias_main: paddle.nn.functional.deformable_roi_pooling
+:alias: paddle.nn.functional.deformable_roi_pooling,paddle.nn.functional.vision.deformable_roi_pooling
+:old_api: paddle.fluid.layers.deformable_roi_pooling
+
+
+
 可变形感兴趣区域（ROI）池化层
 
 该OP对输入进行了可形变的感兴趣区域(ROI)池化操作。如同 `可形变卷积网络 <https://arxiv.org/abs/1703.06211>`_  描述的一样，它将为每个bin中的像素获取一个偏移量，以便于在合适的位置进行池化。在完成可变形感兴趣区域（ROI）池化操作之后，批量数将变为候选框的数量。

doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst

@@ -5,6 +5,12 @@ density_prior_box
 
 .. py:function:: paddle.fluid.layers.density_prior_box(input, image, densities=None, fixed_sizes=None, fixed_ratios=None, variance=[0.1, 0.1, 0.2, 0.2], clip=False, steps=[0.0, 0.0], offset=0.5, flatten_to_2d=False, name=None)
 
+:alias_main: paddle.nn.functional.density_prior_box
+:alias: paddle.nn.functional.density_prior_box,paddle.nn.functional.vision.density_prior_box
+:old_api: paddle.fluid.layers.density_prior_box
+
+
+
 
 该OP为SSD算法(Single Shot MultiBox Detector)生成density prior box，在每个 ``input`` 的位置产生N个候选框，其中，N由 ``densities`` , ``fixed_sizes`` 和 ``fixed_ratios`` 来计算。生成的每个输入位置附近的候选框中心（网格点）由 ``densities`` 和 ``density prior box`` 的数量计算，其中 ``density prior box`` 的数量由 ``fixed_sizes`` 和 ``fixed_ratios`` 决定。``fixed_sizes`` 和 ``densities`` 的大小一致。
 

doc/fluid/api_cn/layers_cn/detection_output_cn.rst

@@ -5,6 +5,12 @@ detection_output
 
 .. py:function:: paddle.fluid.layers.detection_output(loc, scores, prior_box, prior_box_var, background_label=0, nms_threshold=0.3, nms_top_k=400, keep_top_k=200, score_threshold=0.01, nms_eta=1.0)
 
+:alias_main: paddle.nn.functional.detection_output
+:alias: paddle.nn.functional.detection_output,paddle.nn.functional.vision.detection_output
+:old_api: paddle.fluid.layers.detection_output
+
+
+
 给定回归位置偏移、置信度以及先验框信息计算检测的输出，执行步骤如下：
 
     1.根据先验框(``prior_box``)信息和回归位置偏移解码出预测框坐标。

doc/fluid/api_cn/layers_cn/diag_cn.rst

@@ -5,6 +5,12 @@ diag
 
 .. py:function:: paddle.fluid.layers.diag(diagonal)
 
+:alias_main: paddle.diag
+:alias: paddle.diag,paddle.tensor.diag,paddle.tensor.creation.diag
+:old_api: paddle.fluid.layers.diag
+
+
+
 该OP创建一个方阵，使用输入diagonal来指定方阵的对角线元素的值。
 
 参数：

doc/fluid/api_cn/layers_cn/dice_loss_cn.rst

@@ -5,6 +5,12 @@ dice_loss
 
 .. py:function:: paddle.fluid.layers.dice_loss(input, label, epsilon=1e-05)
 
+:alias_main: paddle.nn.functional.dice_loss
+:alias: paddle.nn.functional.dice_loss,paddle.nn.functional.loss.dice_loss
+:old_api: paddle.fluid.layers.dice_loss
+
+
+
 该OP用来比较预测结果跟标签之间的相似度，通常用于二值图像分割，即标签为二值，也可以做多标签的分割。
 
 dice_loss定义为:

doc/fluid/api_cn/layers_cn/distribute_fpn_proposals_cn.rst

@@ -5,6 +5,12 @@ distribute_fpn_proposals
 
 .. py:function:: paddle.fluid.layers.distribute_fpn_proposals(fpn_rois, min_level, max_level, refer_level, refer_scale, name=None)
 
+:alias_main: paddle.nn.functional.distribute_fpn_proposals
+:alias: paddle.nn.functional.distribute_fpn_proposals,paddle.nn.functional.vision.distribute_fpn_proposals
+:old_api: paddle.fluid.layers.distribute_fpn_proposals
+
+
+
 **该op仅支持LoDTensor输入**。在 Feature Pyramid Networks（FPN）模型中，需要依据proposal的尺度和参考尺度与级别将所有proposal分配到不同的FPN级别中。 此外，为了恢复proposals的顺序，我们返回一个数组，该数组表示当前proposals中的原始RoIs索引。 要计算每个RoI的FPN级别，公式如下：
 
 .. math::

doc/fluid/api_cn/layers_cn/double_buffer_cn.rst

@@ -6,6 +6,9 @@ double_buffer
 .. py:function:: paddle.fluid.layers.double_buffer(reader, place=None, name=None)
 
 
+
+
+
 生成一个双缓冲队列Reader。Reader类有DecoratedReader和FileReader，其中DecoratedReader又可以细分成CustomReader和BufferedReader。这里是基于BufferedReader，数据将复制到具有双缓冲队列的位置（由place指定），如果 ``place=None`` 则将使用executor执行的位置。
 
 参数:

doc/fluid/api_cn/layers_cn/dropout_cn.rst

@@ -5,6 +5,12 @@ dropout
 
 .. py:function:: paddle.fluid.layers.dropout(x,dropout_prob,is_test=False,seed=None,name=None,dropout_implementation='downgrade_in_infer')
 
+:alias_main: paddle.nn.functional.dropout
+:alias: paddle.nn.functional.dropout,paddle.nn.functional.common.dropout
+:old_api: paddle.fluid.layers.dropout
+
+
+
 dropout操作
 
 丢弃或者保持x的每个元素独立。Dropout是一种正则化手段，通过在训练过程中阻止神经元节点间的相关性来减少过拟合。根据给定的丢弃概率，dropout操作符按丢弃概率随机将一些神经元输出设置为0，其他的仍保持不变。

doc/fluid/api_cn/layers_cn/dynamic_decode_cn.rst

@@ -4,10 +4,13 @@ dynamic_decode
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:method:: dynamic_decode(decoder, inits=None, max_step_num=None, output_time_major=False, **kwargs):
 
+:api_attr: 声明式编程模式（静态图)
+
+
+    
 该接口重复执行 :code:`decoder.step()` 直到 其返回的表示完成状态的Tensor中的值全部为True或解码步骤达到 :code:`max_step_num`。
 
 :code:`decode.initialize()` 会在解码循环之前被调用一次。如果 :code:`decoder` 实现了 :code:`finalize` 方法，则 :code:`decoder.finalize()` 在解码循环后将被调用一次。

doc/fluid/api_cn/layers_cn/dynamic_gru_cn.rst

@@ -3,10 +3,13 @@
 dynamic_gru
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.dynamic_gru(input, size, param_attr=None, bias_attr=None, is_reverse=False, gate_activation='sigmoid', candidate_activation='tanh', h_0=None, origin_mode=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用StaticRNN（fluid.layers.** :ref:`cn_api_fluid_layers_StaticRNN` **）。**
 

doc/fluid/api_cn/layers_cn/dynamic_lstm_cn.rst

@@ -3,10 +3,13 @@
 dynamic_lstm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.dynamic_lstm(input, size, h_0=None, c_0=None, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', dtype='float32', name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP实现了 LSTM，即 Long-Short Term Memory（长短期记忆）运算 - `Hochreiter, S., & Schmidhuber, J. (1997) <http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf>`_。
 
 .. note::

doc/fluid/api_cn/layers_cn/dynamic_lstmp_cn.rst

@@ -2,10 +2,13 @@
 
 dynamic_lstmp
 -------------------------------
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.dynamic_lstmp(input, size, proj_size, param_attr=None, bias_attr=None, use_peepholes=True, is_reverse=False, gate_activation='sigmoid', cell_activation='tanh', candidate_activation='tanh', proj_activation='tanh', dtype='float32', name=None, h_0=None, c_0=None, cell_clip=None, proj_clip=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     在实现的时候为了提升效率，用户必须将输入先进行线性映射，将维度为 [T, hidden_size] 的输入映射为 [T, 4×hidden_size] 输入，然后再传给该OP。
 

doc/fluid/api_cn/layers_cn/edit_distance_cn.rst

@@ -6,6 +6,12 @@ edit_distance
 
 .. py:function:: paddle.fluid.layers.edit_distance(input,label,normalized=True,ignored_tokens=None, input_length=None, label_length=None）
 
+:alias_main: paddle.nn.functional.edit_distance
+:alias: paddle.nn.functional.edit_distance,paddle.nn.functional.loss.edit_distance
+:old_api: paddle.fluid.layers.edit_distance
+
+
+
 该OP计算一批给定字符串及其参照字符串间的编辑距离。编辑距离也称Levenshtein距离，通过计算从一个字符串变成另一个字符串所需的最少操作步骤来衡量两个字符串的相异度。这里的操作包括插入、删除和替换。
 
 比如给定假设字符串A=“kitten”和参照字符串B=“sitting”，从A变换成B编辑距离为3，至少需要两次替换和一次插入：

doc/fluid/api_cn/layers_cn/elementwise_add_cn.rst

@@ -5,6 +5,12 @@ elementwise_add
 
 .. py:function:: paddle.fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_add
+:alias: paddle.elementwise_add,paddle.tensor.elementwise_add,paddle.tensor.math.elementwise_add
+:old_api: paddle.fluid.layers.elementwise_add
+
+
+
 该OP是逐元素相加算子，输入 ``x`` 与输入 ``y`` 逐元素相加，并将各个位置的输出元素保存到返回结果中。
 
 等式为：

doc/fluid/api_cn/layers_cn/elementwise_div_cn.rst

@@ -5,6 +5,12 @@ elementwise_div
 
 .. py:function:: paddle.fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_div
+:alias: paddle.elementwise_div,paddle.tensor.elementwise_div,paddle.tensor.math.elementwise_div
+:old_api: paddle.fluid.layers.elementwise_div
+
+
+
 该OP是逐元素相除算子，输入 ``x`` 与输入 ``y`` 逐元素相除，并将各个位置的输出元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/layers_cn/elementwise_floordiv_cn.rst

@@ -5,6 +5,12 @@ elementwise_floordiv
 
 .. py:function:: paddle.fluid.layers.elementwise_floordiv(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_floordiv
+:alias: paddle.elementwise_floordiv,paddle.tensor.elementwise_floordiv,paddle.tensor.math.elementwise_floordiv
+:old_api: paddle.fluid.layers.elementwise_floordiv
+
+
+
 该OP是逐元素整除算子，输入 ``x`` 与输入 ``y`` 逐元素整除，并将各个位置的输出元素保存到返回结果中。
 
 等式为：

doc/fluid/api_cn/layers_cn/elementwise_max_cn.rst

@@ -4,6 +4,12 @@ elementwise_max
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.elementwise_max(x, y, axis=-1, act=None, name=None)
+
+:alias_main: paddle.elementwise_max
+:alias: paddle.elementwise_max,paddle.tensor.elementwise_max,paddle.tensor.math.elementwise_max
+:old_api: paddle.fluid.layers.elementwise_max
+
+
 该OP逐元素对比输入的两个多维Tensor，并且把各个位置更大的元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/layers_cn/elementwise_min_cn.rst

@@ -4,6 +4,12 @@ elementwise_min
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.elementwise_min(x, y, axis=-1, act=None, name=None)
+
+:alias_main: paddle.elementwise_min
+:alias: paddle.elementwise_min,paddle.tensor.elementwise_min,paddle.tensor.math.elementwise_min
+:old_api: paddle.fluid.layers.elementwise_min
+
+
 该OP逐元素对比输入的两个多维Tensor，并且把各个位置更小的元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/layers_cn/elementwise_mod_cn.rst

@@ -5,6 +5,12 @@ elementwise_mod
 
 .. py:function:: paddle.fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_mod
+:alias: paddle.elementwise_mod,paddle.tensor.elementwise_mod,paddle.tensor.math.elementwise_mod
+:old_api: paddle.fluid.layers.elementwise_mod
+
+
+
 该OP是逐元素取模算子，输入 ``x`` 与输入 ``y`` 逐元素取模，并将各个位置的输出元素保存到返回结果中。
 
 等式为：

doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst

@@ -5,6 +5,12 @@ elementwise_mul
 
 .. py:function:: paddle.fluid.layers.elementwise_mul(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_mul
+:alias: paddle.elementwise_mul,paddle.tensor.elementwise_mul,paddle.tensor.math.elementwise_mul
+:old_api: paddle.fluid.layers.elementwise_mul
+
+
+
 该OP是逐元素相乘算子，输入 ``x`` 与输入 ``y`` 逐元素相乘，并将各个位置的输出元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/layers_cn/elementwise_pow_cn.rst

@@ -4,6 +4,12 @@ elementwise_pow
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.elementwise_pow(x, y, axis=-1, act=None, name=None)
+
+:alias_main: paddle.elementwise_pow
+:alias: paddle.elementwise_pow,paddle.tensor.elementwise_pow,paddle.tensor.math.elementwise_pow
+:old_api: paddle.fluid.layers.elementwise_pow
+
+
 该OP逐元素对输入Tensor进行幂操作。
 
 等式是：

doc/fluid/api_cn/layers_cn/elementwise_sub_cn.rst

@@ -5,6 +5,12 @@ elementwise_sub
 
 .. py:function:: paddle.fluid.layers.elementwise_sub(x, y, axis=-1, act=None, name=None)
 
+:alias_main: paddle.elementwise_sub
+:alias: paddle.elementwise_sub,paddle.tensor.elementwise_sub,paddle.tensor.math.elementwise_sub
+:old_api: paddle.fluid.layers.elementwise_sub
+
+
+
 该OP是逐元素相减算子，输入 ``x`` 与输入 ``y`` 逐元素相减，并将各个位置的输出元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/layers_cn/elu_cn.rst

@@ -5,6 +5,12 @@ elu
 
 .. py:function:: paddle.fluid.layers.elu(x, alpha=1.0, name=None)
 
+:alias_main: paddle.nn.functional.elu
+:alias: paddle.nn.functional.elu,paddle.nn.functional.activation.elu
+:old_api: paddle.fluid.layers.elu
+
+
+
 ELU激活层（ELU Activation Operator）
 
 根据 https://arxiv.org/abs/1511.07289 对输入Tensor中每个元素应用以下计算。

doc/fluid/api_cn/layers_cn/embedding_cn.rst

@@ -3,10 +3,13 @@
 embedding
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.embedding(input, size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 嵌入层(Embedding Layer)
 
 **注意：此OP将在未来的版本中被移除！该OP要求输入Tensor shape的最后一维必须为1。推荐使用fluid.** :ref:`cn_api_fluid_embedding` 。

doc/fluid/api_cn/layers_cn/equal_cn.rst

@@ -5,6 +5,9 @@ equal
 
 .. py:function:: paddle.fluid.layers.equal(x,y,cond=None)
 
+
+
+
 该OP返回 :math:`x==y` 逐元素比较x和y是否相等，x和y的维度应该相同。
 
 参数：

doc/fluid/api_cn/layers_cn/erf_cn.rst

@@ -5,6 +5,12 @@ erf
 
 .. py:function:: paddle.fluid.layers.erf(x)
 
+:alias_main: paddle.erf
+:alias: paddle.erf,paddle.tensor.erf,paddle.tensor.math.erf,paddle.nn.functional.erf,paddle.nn.functional.activation.erf
+:old_api: paddle.fluid.layers.erf
+
+
+
 逐元素计算 Erf 激活函数。更多细节请参考 `Error function <https://en.wikipedia.org/wiki/Error_function>`_ 。
 
 

doc/fluid/api_cn/layers_cn/exp_cn.rst

@@ -5,6 +5,12 @@ exp
 
 .. py:function:: paddle.fluid.layers.exp(x, name=None)
 
+:alias_main: paddle.exp
+:alias: paddle.exp,paddle.tensor.exp,paddle.tensor.math.exp
+:old_api: paddle.fluid.layers.exp
+
+
+
 对输入，逐元素进行以自然数e为底指数运算。
 
 .. math::

doc/fluid/api_cn/layers_cn/expand_as_cn.rst

@@ -5,6 +5,12 @@ expand_as
 
 .. py:function:: paddle.fluid.layers.expand_as(x, target_tensor, name=None)
 
+:alias_main: paddle.expand_as
+:alias: paddle.expand_as,paddle.tensor.expand_as,paddle.tensor.manipulation.expand_as
+:old_api: paddle.fluid.layers.expand_as
+
+
+
 该OP会根据输入的variable ``target_tensor`` 对输入 ``x`` 的各维度进行广播。通过 ``target_tensor``的维度来为 ``x`` 的每个维度设置广播的次数，使得x 的维度与target_tensor的维度相同。 ``x`` 的秩应小于等于6。注意， ``target_tensor`` 的秩必须与 ``x`` 的秩相同。
 注意:``target_tensor`` 对应的每一维必须能整除输入x中对应的维度，否则会报错。比如，target_tensor的维度为[2,6,2],x为[2,3,1],则整除后为[1,2,2]，x广播后维度为[2,6,2]。如果target_tensor的维度为[2,5,2]，第二维5不能整除x的第二维3，则会报错。        
 

doc/fluid/api_cn/layers_cn/expand_cn.rst

@@ -5,6 +5,12 @@ expand
 
 .. py:function:: paddle.fluid.layers.expand(x, expand_times, name=None)
 
+:alias_main: paddle.expand
+:alias: paddle.expand,paddle.tensor.expand,paddle.tensor.manipulation.expand
+:old_api: paddle.fluid.layers.expand
+
+
+
 该OP会根据参数 ``expand_times`` 对输入 ``x`` 的各维度进行复制。通过参数 ``expand_times`` 来为 ``x`` 的每个维度设置复制次数。 ``x`` 的秩应小于等于6。注意， ``expand_times`` 的大小必须与 ``x`` 的秩相同。以下是一个用例：
 
 ::

doc/fluid/api_cn/layers_cn/exponential_decay_cn.rst

@@ -5,6 +5,12 @@ exponential_decay
 
 .. py:function:: paddle.fluid.layers.exponential_decay(learning_rate,decay_steps,decay_rate,staircase=False)
 
+:alias_main: paddle.nn.functional.exponential_decay
+:alias: paddle.nn.functional.exponential_decay,paddle.nn.functional.learning_rate.exponential_decay
+:old_api: paddle.fluid.layers.exponential_decay
+
+
+
 在学习率上运用指数衰减。
 
 训练模型时，在训练过程中降低学习率。每 ``decay_steps`` 步骤中以 ``decay_rate`` 衰减学习率。

doc/fluid/api_cn/layers_cn/eye_cn.rst

@@ -5,6 +5,12 @@ eye
 
 .. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32')
 
+:alias_main: paddle.eye
+:alias: paddle.eye,paddle.tensor.eye,paddle.tensor.creation.eye
+:update_api: paddle.fluid.layers.eye
+
+
+
 该OP用来构建单位矩阵，或一个批次的单位矩阵。
 
 参数：

doc/fluid/api_cn/layers_cn/fc_cn.rst

@@ -3,10 +3,13 @@
 fc
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.fc(input, size, num_flatten_dims=1, param_attr=None, bias_attr=None, act=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 **全连接层**
 

doc/fluid/api_cn/layers_cn/fill_constant_cn.rst

@@ -5,6 +5,12 @@ fill_constant
 
 .. py:function:: paddle.fluid.layers.fill_constant(shape,dtype,value,force_cpu=False,out=None)
 
+:alias_main: paddle.fill_constant
+:alias: paddle.fill_constant,paddle.tensor.fill_constant,paddle.tensor.creation.fill_constant
+:old_api: paddle.fluid.layers.fill_constant
+
+
+
 该OP创建一个形状为shape并且数据类型为dtype的Tensor，同时用 ``value`` 中提供的常量初始化该Tensor。
 
 创建的Tensor的stop_gradient属性默认为True。

doc/fluid/api_cn/layers_cn/filter_by_instag_cn.rst

@@ -5,6 +5,12 @@ filter_by_instag
 
 .. py:function:: paddle.fluid.layers.filter_by_instag(ins, ins_tag, filter_tag, is_lod)
 
+:alias_main: paddle.nn.functional.filter_by_instag
+:alias: paddle.nn.functional.filter_by_instag,paddle.nn.functional.extension.filter_by_instag
+:old_api: paddle.fluid.layers.filter_by_instag
+
+
+
 此函数通过instag来过滤ins batch，大量属于同样的tags的样本，我们可以指定我们想要的一些tags，属于这些tags的样本将会被保留在输出中，其余的将会移除。比如，一个batch有4个样本，每个样本都有自己的tag表。
 
 Ins   |   Ins_Tag |

doc/fluid/api_cn/layers_cn/flatten_cn.rst

@@ -5,6 +5,12 @@ flatten
 
 .. py:function::  paddle.fluid.layers.flatten(x, axis=1, name=None)
 
+:alias_main: paddle.flatten
+:alias: paddle.flatten,paddle.tensor.flatten,paddle.tensor.manipulation.flatten
+:old_api: paddle.fluid.layers.flatten
+
+
+
 flatten op将输入的多维Tensor展平成2-D Tensor矩阵
 
 例如：

doc/fluid/api_cn/layers_cn/floor_cn.rst

@@ -5,6 +5,12 @@ floor
 
 .. py:function:: paddle.fluid.layers.floor(x, name=None)
 
+:alias_main: paddle.floor
+:alias: paddle.floor,paddle.tensor.floor,paddle.tensor.math.floor
+:old_api: paddle.fluid.layers.floor
+
+
+
 向下取整函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/fsp_matrix_cn.rst

@@ -5,6 +5,12 @@ fsp_matrix
 
 .. py:function:: paddle.fluid.layers.fsp_matrix(x, y)
 
+:alias_main: paddle.nn.functional.fsp_matrix
+:alias: paddle.nn.functional.fsp_matrix,paddle.nn.functional.vision.fsp_matrix
+:old_api: paddle.fluid.layers.fsp_matrix
+
+
+
 **FSP matrix op**
 
 fsp_matrix op用于计算两个4-D Tensor特征图的求解过程（FSP）矩阵。假设特征图x的形状为 :math:`[x\_channel，h，w]` ，特征图y的形状为 :math:`[y\_channel，h，w]` ，fsp_matrix op分两步得到x和y的fsp矩阵：

doc/fluid/api_cn/layers_cn/gather_cn.rst

@@ -5,6 +5,9 @@ gather
 
 .. py:function:: paddle.fluid.layers.gather(input, index, overwrite=True)
 
+
+
+
 根据索引 ``index`` 获取输入（input）的最外层维度的条目，并将它们拼接在一起。
 
 .. math::

doc/fluid/api_cn/layers_cn/gather_nd_cn.rst

@@ -5,6 +5,12 @@ gather_nd
 
 .. 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维张量，每一个元素是一个切片：
 
 .. math::

doc/fluid/api_cn/layers_cn/gather_tree_cn.rst

@@ -5,6 +5,12 @@ gather_tree
 
 .. py:function:: paddle.fluid.layers.gather_tree(ids, parents)
 
+:alias_main: paddle.nn.gather_tree
+:alias: paddle.nn.gather_tree,paddle.nn.decode.gather_tree
+:old_api: paddle.fluid.layers.gather_tree
+
+
+
 该OP在整个束搜索(Beam Search)结束后使用。在搜索结束后，可以获得每个时间步选择的的候选词id及其对应的在搜索树中的parent节点， ``ids`` 和 ``parents`` 的形状布局均为 :math:`[max\_time, batch\_size, beam\_size]` ，该OP从最后一个时间步回溯产生完整的id序列。
 
 

doc/fluid/api_cn/layers_cn/gaussian_random_cn.rst

@@ -5,6 +5,9 @@ gaussian_random
 
 .. py:function:: paddle.fluid.layers.gaussian_random(shape, mean=0.0, std=1.0, seed=0, dtype='float32')
 
+
+
+
 生成数据符合高斯随机分布的 Tensor。
 
 参数：

doc/fluid/api_cn/layers_cn/gelu_cn.rst

@@ -5,6 +5,12 @@ gelu
 
 .. py:function:: paddle.fluid.layers.gelu(x)
 
+:alias_main: paddle.nn.functional.gelu
+:alias: paddle.nn.functional.gelu,paddle.nn.functional.activation.gelu
+:old_api: paddle.fluid.layers.gelu
+
+
+
 逐元素计算 Gelu激活函数。更多细节请参考 `Gaussian Error Linear Units <https://arxiv.org/abs/1606.08415>`_ 。
 
 如果使用近似计算：

doc/fluid/api_cn/layers_cn/generate_mask_labels_cn.rst

@@ -5,6 +5,12 @@ generate_mask_labels
 
 .. py:function:: paddle.fluid.layers.generate_mask_labels(im_info, gt_classes, is_crowd, gt_segms, rois, labels_int32, num_classes, resolution)
 
+:alias_main: paddle.nn.functional.generate_mask_labels
+:alias: paddle.nn.functional.generate_mask_labels,paddle.nn.functional.vision.generate_mask_labels
+:old_api: paddle.fluid.layers.generate_mask_labels
+
+
+
 **为Mask-RCNN生成mask标签**
 
 对于给定的 RoI (Regions of Interest) 和 输入ground truth的分类标签和分割的坐标标签，采样出前景RoI，并返回其在输入 ``rois`` 中索引位置，并对每个RoI生成 :math:`K*M^{2}` 的二值mask标签。K为类别个数，M是RoI特征图大小。这些输出目标一般用于计算mask分支的损失。

doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst

@@ -5,6 +5,12 @@ generate_proposal_labels
 
 .. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], class_nums=None, use_random=True, is_cls_agnostic=False, is_cascade_rcnn=False)
 
+:alias_main: paddle.nn.functional.generate_proposal_labels
+:alias: paddle.nn.functional.generate_proposal_labels,paddle.nn.functional.vision.generate_proposal_labels
+:old_api: paddle.fluid.layers.generate_proposal_labels
+
+
+
 **注意：该OP无对应的反向OP**
 
 该OP根据RPN预测产出的bounding boxes和groundtruth，抽取出用来计算loss的foreground boxes and background boxes。

doc/fluid/api_cn/layers_cn/generate_proposals_cn.rst

@@ -5,6 +5,12 @@ generate_proposals
 
 .. py:function:: paddle.fluid.layers.generate_proposals(scores, bbox_deltas, im_info, anchors, variances, pre_nms_top_n=6000, post_nms_top_n=1000, nms_thresh=0.5, min_size=0.1, eta=1.0, name=None)
 
+:alias_main: paddle.nn.functional.generate_proposals
+:alias: paddle.nn.functional.generate_proposals,paddle.nn.functional.vision.generate_proposals
+:old_api: paddle.fluid.layers.generate_proposals
+
+
+
 
 该OP根据每个检测框为foreground对象的概率，推选生成用于后续检测网络的RoIs。
 其中的检测框根据 ``anchors`` 和 ``bbox_deltas`` 计算得到。

doc/fluid/api_cn/layers_cn/get_tensor_from_selected_rows_cn.rst

@@ -5,6 +5,9 @@ get_tensor_from_selected_rows
 
 .. py:function::  paddle.fluid.layers.get_tensor_from_selected_rows(x, name=None)
 
+
+
+
 该OP从SelectedRows类型的输入中获取向量数据，以LoDTensor的形式输出。
 
 

doc/fluid/api_cn/layers_cn/greater_equal_cn.rst

@@ -5,6 +5,12 @@ greater_equal
 
 .. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=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` 的逻辑值，使用重载算子 `>=` 可以有相同的计算函数效果。
 
 

doc/fluid/api_cn/layers_cn/greater_than_cn.rst

@@ -5,6 +5,12 @@ greater_than
 
 .. py:function:: paddle.fluid.layers.greater_than(x, y, cond=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` 的逻辑值，使用重载算子 `>` 可以有相同的计算函数效果。
 
 参数：

doc/fluid/api_cn/layers_cn/grid_sampler_cn.rst

@@ -5,6 +5,12 @@ grid_sampler
 
 .. py:function::  paddle.fluid.layers.grid_sampler(x, grid, name=None)
 
+:alias_main: paddle.nn.functional.grid_sampler
+:alias: paddle.nn.functional.grid_sampler,paddle.nn.functional.vision.grid_sampler
+:old_api: paddle.fluid.layers.grid_sampler
+
+
+
 该OP基于flow field网格的对输入X进行双线性插值采样。网格通常由affine_grid生成, shape为[N, H, W, 2]，是shape为[N, H, W]的采样点张量的(x, y)坐标。
 其中，x坐标是对输入数据X的第四个维度(宽度维度)的索引，y坐标是第三维度(高维度)的索引，最终输出采样值为采样点的4个最接近的角点的双线性插值结果，输出张量的shape为[N, C, H, W]。
 

doc/fluid/api_cn/layers_cn/group_norm_cn.rst

@@ -3,10 +3,13 @@
 group_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.group_norm(input, groups, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, data_layout='NCHW', name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 参考论文： `Group Normalization <https://arxiv.org/abs/1803.08494>`_
 
 参数：

doc/fluid/api_cn/layers_cn/gru_unit_cn.rst

@@ -3,10 +3,13 @@
 gru_unit
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.gru_unit(input, hidden, size, param_attr=None, bias_attr=None, activation='tanh', gate_activation='sigmoid', origin_mode=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 Gated Recurrent Unit（GRU）循环神经网络计算单元。该OP用于完成单个时间步内GRU的计算，支持以下两种计算方式：
 
 如果origin_mode为True，则使用的运算公式来自论文

doc/fluid/api_cn/layers_cn/hard_shrink_cn.rst

@@ -5,6 +5,12 @@ hard_shrink
 
 .. py:function:: paddle.fluid.layers.hard_shrink(x,threshold=None)
 
+:alias_main: paddle.nn.functional.hard_shrink
+:alias: paddle.nn.functional.hard_shrink,paddle.nn.functional.activation.hard_shrink
+:old_api: paddle.fluid.layers.hard_shrink
+
+
+
 HardShrink激活函数(HardShrink activation operator)
 
 

doc/fluid/api_cn/layers_cn/hard_sigmoid_cn.rst

@@ -5,6 +5,12 @@ hard_sigmoid
 
 .. py:function:: paddle.fluid.layers.hard_sigmoid(x, slope=0.2, offset=0.5, name=None)
 
+:alias_main: paddle.nn.functional.hard_sigmoid
+:alias: paddle.nn.functional.hard_sigmoid,paddle.nn.functional.activation.hard_sigmoid
+:old_api: paddle.fluid.layers.hard_sigmoid
+
+
+
 sigmoid的分段线性逼近激活函数，速度比sigmoid快，详细解释参见 https://arxiv.org/abs/1603.00391。
 
 .. math::

doc/fluid/api_cn/layers_cn/hard_swish_cn.rst

@@ -5,6 +5,12 @@ hard_swish
 
 .. py:function:: paddle.fluid.layers.hard_swish(x, threshold=6.0, scale=6.0, offset=3.0, name=None)
 
+:alias_main: paddle.nn.functional.hard_swish
+:alias: paddle.nn.functional.hard_swish,paddle.nn.functional.activation.hard_swish
+:old_api: paddle.fluid.layers.hard_swish
+
+
+
 该OP实现了hard_swish激活函数。hard_swish激活函数在MobileNetV3架构中被提出，相较于swish函数，具有数值稳定性好，计算速度快等优点，具体原理请参考: https://arxiv.org/pdf/1905.02244.pdf
 
  :math:`out = \frac{x * (min(max(0, x+offset), threshold))}{scale}`

doc/fluid/api_cn/layers_cn/has_inf_cn.rst

@@ -5,6 +5,12 @@ has_inf
 
 .. py:function:: paddle.fluid.layers.has_inf(x)
 
+:alias_main: paddle.has_inf
+:alias: paddle.has_inf,paddle.tensor.has_inf,paddle.tensor.search.has_inf
+:old_api: paddle.fluid.layers.has_inf
+
+
+
 检查输入的变量(x)中是否包含无穷数(inf)。
 
 参数：

doc/fluid/api_cn/layers_cn/has_nan_cn.rst

@@ -5,6 +5,12 @@ has_nan
 
 .. py:function:: paddle.fluid.layers.has_nan(x)
 
+:alias_main: paddle.has_nan
+:alias: paddle.has_nan,paddle.tensor.has_nan,paddle.tensor.search.has_nan
+:old_api: paddle.fluid.layers.has_nan
+
+
+
 检查输入的变量(x)中是否包含NAN。
 
 参数：

doc/fluid/api_cn/layers_cn/hash_cn.rst

@@ -5,6 +5,12 @@ hash
 
 .. py:function::  paddle.fluid.layers.hash(input, hash_size, num_hash=1, name=None)
 
+:alias_main: paddle.nn.functional.hash
+:alias: paddle.nn.functional.hash,paddle.nn.functional.lod.hash
+:old_api: paddle.fluid.layers.hash
+
+
+
 该OP将输入 hash 成为一个整数，该数的值小于给定的 ``hash_size`` 。**仅支持输入为LoDTensor**。
 
 该OP使用的哈希算法是：xxHash - `Extremely fast hash algorithm <https://github.com/Cyan4973/xxHash/tree/v0.6.5>`_

doc/fluid/api_cn/layers_cn/hsigmoid_cn.rst

@@ -3,10 +3,13 @@
 hsigmoid
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_classes, param_attr=None, bias_attr=None, name=None, path_table=None, path_code=None, is_custom=False, is_sparse=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 层次sigmoid（hierarchical sigmoid），该OP通过构建一个分类二叉树来降低计算复杂度，主要用于加速语言模型的训练过程。
 
 该OP建立的二叉树中每个叶节点表示一个类别(单词)，每个非叶子节点代表一个二类别分类器（sigmoid）。对于每个类别（单词），都有一个从根节点到它的唯一路径，hsigmoid累加这条路径上每个非叶子节点的损失得到总损失。

doc/fluid/api_cn/layers_cn/huber_loss_cn.rst

@@ -5,6 +5,12 @@ huber_loss
 
 .. py:function:: paddle.fluid.layers.huber_loss(input, label, delta)
 
+:alias_main: paddle.nn.functional.huber_loss
+:alias: paddle.nn.functional.huber_loss,paddle.nn.functional.loss.huber_loss
+:old_api: paddle.fluid.layers.huber_loss
+
+
+
 
 该OP计算输入（input）与标签（label）之间的Huber损失。Huber损失是常用的回归损失之一，相较于平方误差损失，Huber损失减小了对异常点的敏感度，更具鲁棒性。
 

doc/fluid/api_cn/layers_cn/im2sequence_cn.rst

@@ -3,10 +3,13 @@
 im2sequence
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.im2sequence(input, filter_size=1, stride=1, padding=0, input_image_size=None, out_stride=1, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP使用 `filter` 扫描输入的Tensor并将输入Tensor转换成序列，返回值的 `shape={input.batch_size * output_height * output_width, filter_size_height* filter_size_width * input.channels}` 。返回值的timestep的个数为 `output_height * output_width` ， 每个timestep的维度是 `filter_size_height* filter_size_width * input.channels` 。其中 `output_height` 和 `output_width` 由以下式计算:
 
 

doc/fluid/api_cn/layers_cn/image_resize_cn.rst

@@ -5,6 +5,12 @@ image_resize
 
 .. py:function:: paddle.fluid.layers.image_resize(input, out_shape=None, scale=None, name=None, resample='BILINEAR', actual_shape=None, align_corners=True, align_mode=1, data_format='NCHW')
 
+:alias_main: paddle.nn.functional.image_resize
+:alias: paddle.nn.functional.image_resize,paddle.nn.functional.vision.image_resize
+:old_api: paddle.fluid.layers.image_resize
+
+
+
 **注意:** 参数 ``actual_shape`` 将被弃用，请使用 ``out_shape`` 替代。
 
 该OP用于调整一个batch中图片的大小。

doc/fluid/api_cn/layers_cn/image_resize_short_cn.rst

@@ -5,6 +5,12 @@ image_resize_short
 
 .. py:function:: paddle.fluid.layers.image_resize_short(input, out_short_len, resample='BILINEAR')
 
+:alias_main: paddle.nn.functional.image_resize_short
+:alias: paddle.nn.functional.image_resize_short,paddle.nn.functional.vision.image_resize_short
+:old_api: paddle.fluid.layers.image_resize_short
+
+
+
 该OP用于调整一批图片的大小。输入图像的短边将被调整为给定的out_short_len 。输入图像的长边按比例调整大小，最终图像的长宽比保持不变。
 
 参数:

doc/fluid/api_cn/layers_cn/increment_cn.rst

@@ -5,6 +5,12 @@ increment
 
 .. py:function:: paddle.fluid.layers.increment(x, value=1.0, in_place=True)
 
+:alias_main: paddle.increment
+:alias: paddle.increment,paddle.tensor.increment,paddle.tensor.math.increment
+:old_api: paddle.fluid.layers.increment
+
+
+
 使输入Tensor ``x`` 的数据累加 ``value`` , 该OP通常用于循环次数的计数。
 
 参数:

doc/fluid/api_cn/layers_cn/instance_norm_cn.rst

@@ -3,10 +3,13 @@
 instance_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.instance_norm(input, epsilon=1e-05, param_attr=None, bias_attr=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 可用作卷积和全连接操作的实例正则化函数，根据每个样本的每个通道的均值和方差信息进行正则化。该层需要的数据格式如下：
 

doc/fluid/api_cn/layers_cn/inverse_time_decay_cn.rst

@@ -5,6 +5,12 @@ inverse_time_decay
 
 .. py:function:: paddle.fluid.layers.inverse_time_decay(learning_rate, decay_steps, decay_rate, staircase=False)
 
+:alias_main: paddle.nn.functional.inverse_time_decay
+:alias: paddle.nn.functional.inverse_time_decay,paddle.nn.functional.learning_rate.inverse_time_decay
+:old_api: paddle.fluid.layers.inverse_time_decay
+
+
+
 在初始学习率上运用逆时衰减。
 
 训练模型时，最好在训练过程中降低学习率。通过执行该函数，将对初始学习率运用逆时衰减函数。

doc/fluid/api_cn/layers_cn/iou_similarity_cn.rst

@@ -5,6 +5,12 @@ iou_similarity
 
 .. py:function:: paddle.fluid.layers.iou_similarity(x, y, box_normalized=True, name=None)
 
+:alias_main: paddle.nn.functional.iou_similarity
+:alias: paddle.nn.functional.iou_similarity,paddle.nn.functional.loss.iou_similarity
+:old_api: paddle.fluid.layers.iou_similarity
+
+
+
 **IOU Similarity Operator**
 
 计算两个框列表的intersection-over-union(IOU)。框列表 :math:`X` 应为LoDTensor， :math:`Y` 是普通张量， :math:`X` 成批输入的所有实例共享 :math:`Y` 中的框。给定框A和框B，IOU的运算如下：

doc/fluid/api_cn/layers_cn/is_empty_cn.rst

@@ -5,6 +5,12 @@ is_empty
 
 .. py:function:: paddle.fluid.layers.is_empty(x, cond=None)
 
+:alias_main: paddle.is_empty
+:alias: paddle.is_empty,paddle.tensor.is_empty,paddle.tensor.logic.is_empty
+:old_api: paddle.fluid.layers.is_empty
+
+
+
 测试变量是否为空
 
 参数：

doc/fluid/api_cn/layers_cn/isfinite_cn.rst

@@ -5,6 +5,12 @@ isfinite
 
 .. py:function:: paddle.fluid.layers.isfinite(x)
 
+:alias_main: paddle.isfinite
+:alias: paddle.isfinite,paddle.tensor.isfinite,paddle.tensor.logic.isfinite
+:old_api: paddle.fluid.layers.isfinite
+
+
+
 ``注意：此算子的输入 Tensor / LoDTensor 数据类型必须为 int32 / float / double 之一。``
 
 测试 x 是否包含无穷值（即 nan 或 inf）。若元素均为有穷数，返回真；否则返回假。

doc/fluid/api_cn/layers_cn/kldiv_loss_cn.rst

@@ -5,6 +5,12 @@ kldiv_loss
 
 .. py:function:: paddle.fluid.layers.kldiv_loss(x, target, reduction='mean', name=None)
 
+:alias_main: paddle.nn.functional.kldiv_loss
+:alias: paddle.nn.functional.kldiv_loss,paddle.nn.functional.loss.kldiv_loss
+:old_api: paddle.fluid.layers.kldiv_loss
+
+
+
 该OP计算输入(X)和输入(Target)之间的Kullback-Leibler散度损失。注意其中输入(X)应为对数概率值，输入(Target)应为概率值。
 
 kL发散损失计算如下：

doc/fluid/api_cn/layers_cn/l2_normalize_cn.rst

@@ -5,6 +5,12 @@ l2_normalize
 
 .. py:function:: paddle.fluid.layers.l2_normalize(x,axis,epsilon=1e-12,name=None)
 
+:alias_main: paddle.nn.functional.l2_normalize
+:alias: paddle.nn.functional.l2_normalize,paddle.nn.functional.norm.l2_normalize
+:old_api: paddle.fluid.layers.l2_normalize
+
+
+
 该OP计算欧几里得距离之和对x进行归一化。对于1-D张量（系数矩阵的维度固定为0）
 计算公式如下：
 

doc/fluid/api_cn/layers_cn/label_smooth_cn.rst

@@ -5,6 +5,12 @@ label_smooth
 
 .. py:function:: paddle.fluid.layers.label_smooth(label, prior_dist=None, epsilon=0.1, dtype='float32', name=None)
 
+:alias_main: paddle.nn.functional.label_smooth
+:alias: paddle.nn.functional.label_smooth,paddle.nn.functional.common.label_smooth
+:old_api: paddle.fluid.layers.label_smooth
+
+
+
 该OP实现了标签平滑的功能。标签平滑是一种对分类器层进行正则化的机制，称为标签平滑正则化(LSR)。由于直接优化正确标签的对数似然可能会导致过拟合，降低模型的适应能力，因此提出了标签平滑的方法来降低模型置信度。
 
 标签平滑使用标签 :math:`y` 和一些固定模式随机分布变量 :math:`\mu` 。对 :math:`k` 标签，标签平滑的计算方式如下。

doc/fluid/api_cn/layers_cn/layer_norm_cn.rst

@@ -3,10 +3,13 @@
 layer_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.layer_norm(input, scale=True, shift=True, begin_norm_axis=1, epsilon=1e-05, param_attr=None, bias_attr=None, act=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP实现了层归一化层（Layer Normalization Layer），其可以应用于小批量输入数据。更多详情请参考：`Layer Normalization <https://arxiv.org/pdf/1607.06450v1.pdf>`_
 
 计算公式如下

doc/fluid/api_cn/layers_cn/leaky_relu_cn.rst

@@ -5,6 +5,12 @@ leaky_relu
 
 .. py:function:: paddle.fluid.layers.leaky_relu(x, alpha=0.02, name=None)
 
+:alias_main: paddle.nn.functional.leaky_relu
+:alias: paddle.nn.functional.leaky_relu,paddle.nn.functional.activation.leaky_relu
+:old_api: paddle.fluid.layers.leaky_relu
+
+
+
 LeakyRelu激活函数
 
 .. math::   out=max(x,α∗x)

doc/fluid/api_cn/layers_cn/less_equal_cn.rst

@@ -5,6 +5,12 @@ less_equal
 
 .. py:function:: paddle.fluid.layers.less_equal(x, y, cond=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` 的逻辑值，使用重载算子 `<=` 可以有相同的计算函数效果。
 
 参数：

doc/fluid/api_cn/layers_cn/less_than_cn.rst

@@ -5,6 +5,12 @@ less_than
 
 .. py:function:: paddle.fluid.layers.less_than(x, y, force_cpu=None, cond=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` 的逻辑值，使用重载算子 `<` 可以有相同的计算函数效果
 

doc/fluid/api_cn/layers_cn/linear_chain_crf_cn.rst

@@ -3,10 +3,13 @@
 linear_chain_crf
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.linear_chain_crf(input, label, param_attr=None, length=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 线性链条件随机场（Linear Chain CRF）
 
 条件随机场定义间接概率图，节点代表随机变量，边代表两个变量之间的依赖。CRF学习条件概率 :math:`P\left ( Y|X \right )` ， :math:`X = \left ( x_{1},x_{2},...,x_{n} \right )` 是结构性输入，:math:`Y = \left ( y_{1},y_{2},...,y_{n} \right )` 为输入标签。

doc/fluid/api_cn/layers_cn/linear_lr_warmup_cn.rst

@@ -5,6 +5,12 @@ linear_lr_warmup
 
 .. py:function:: paddle.fluid.layers.linear_lr_warmup(learning_rate, warmup_steps, start_lr, end_lr)
 
+:alias_main: paddle.nn.functional.linear_lr_warmup
+:alias: paddle.nn.functional.linear_lr_warmup,paddle.nn.functional.learning_rate.linear_lr_warmup
+:old_api: paddle.fluid.layers.linear_lr_warmup
+
+
+
 
 该OP使用学习率优化策略-线性学习率热身(warm up)对学习率进行初步调整。在正常调整学习率之前，先逐步增大学习率，具体原理可参考： `Bag of Tricks for Image Classification with Convolutional Neural Networks <https://arxiv.org/abs/1812.01187>`_
 

doc/fluid/api_cn/layers_cn/linspace_cn.rst

@@ -5,6 +5,9 @@ linspace
 
 .. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
 
+
+
+
 该OP在给定区间内返回固定数目的均匀间隔的值。
  
 参数：

doc/fluid/api_cn/layers_cn/load_cn.rst

@@ -5,6 +5,9 @@ load
 
 .. py:function:: paddle.fluid.layers.load(out, file_path, load_as_fp16=None)
 
+
+
+
 该OP操作将从磁盘文件中加载LoDTensor/SelectedRows变量。
 
 

doc/fluid/api_cn/layers_cn/locality_aware_nms_cn.rst

@@ -5,6 +5,9 @@ locality_aware_nms
 
 .. py:function:: paddle.fluid.layers.locality_aware_nms(bboxes, scores, score_threshold, nms_top_k, keep_top_k, nms_threshold=0.3, normalized=True, nms_eta=1.0, background_label=-1, name=None)
 
+
+
+
 **局部感知NMS**
 
 `局部感知NMS <https://arxiv.org/abs/1704.03155>`_ 用于对边界框（bounding box）和评分（scores）执行局部感知非极大值抑制（LANMS）。

doc/fluid/api_cn/layers_cn/lod_append_cn.rst

@@ -5,6 +5,9 @@ lod_append
 
 .. py:function:: paddle.fluid.layers.lod_append(x, level)
 
+
+
+
 给 ``x`` 的LoD添加 ``level`` 。
 
 简单示例：

doc/fluid/api_cn/layers_cn/lod_reset_cn.rst

@@ -5,6 +5,9 @@ lod_reset
 
 .. py:function:: paddle.fluid.layers.lod_reset(x, y=None, target_lod=None)
 
+
+
+
 根据给定的参数 ``y`` 或 ``target_lod`` ，重设输入 ``x`` (LoDTensor) 的 LoD 信息。
 
 参数：

doc/fluid/api_cn/layers_cn/log_cn.rst

@@ -5,6 +5,12 @@ log
 
 .. py:function:: paddle.fluid.layers.log(x, name=None)
 
+:alias_main: paddle.log
+:alias: paddle.log,paddle.tensor.log,paddle.tensor.math.log
+:old_api: paddle.fluid.layers.log
+
+
+
 
 Log激活函数（计算自然对数）
 

doc/fluid/api_cn/layers_cn/log_loss_cn.rst

@@ -5,6 +5,12 @@ log_loss
 
 .. py:function:: paddle.fluid.layers.log_loss(input, label, epsilon=0.0001, name=None)
 
+:alias_main: paddle.nn.functional.log_loss
+:alias: paddle.nn.functional.log_loss,paddle.nn.functional.loss.log_loss
+:old_api: paddle.fluid.layers.log_loss
+
+
+
 **负log loss层**
 
 该 OP 对输入的预测结果和目标标签进行计算，返回负对数损失值。

doc/fluid/api_cn/layers_cn/logical_and_cn.rst

@@ -5,6 +5,12 @@ logical_and
 
 .. py:function:: paddle.fluid.layers.logical_and(x, y, out=None, name=None)
 
+:alias_main: paddle.logical_and
+:alias: paddle.logical_and,paddle.tensor.logical_and,paddle.tensor.logic.logical_and
+:old_api: paddle.fluid.layers.logical_and
+
+
+
 该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑与运算。
 
 .. math::

doc/fluid/api_cn/layers_cn/logical_not_cn.rst

@@ -5,6 +5,12 @@ logical_not
 
 .. py:function:: paddle.fluid.layers.logical_not(x, out=None, name=None)
 
+:alias_main: paddle.logical_not
+:alias: paddle.logical_not,paddle.tensor.logical_not,paddle.tensor.logic.logical_not
+:old_api: paddle.fluid.layers.logical_not
+
+
+
 该OP逐元素的对 ``X`` LoDTensor/Tensor进行逻辑非运算
 
 .. math::

doc/fluid/api_cn/layers_cn/logical_or_cn.rst

@@ -5,6 +5,12 @@ logical_or
 
 .. py:function:: paddle.fluid.layers.logical_or(x, y, out=None, name=None)
 
+:alias_main: paddle.logical_or
+:alias: paddle.logical_or,paddle.tensor.logical_or,paddle.tensor.logic.logical_or
+:old_api: paddle.fluid.layers.logical_or
+
+
+
 该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑或运算。
 
 .. math::

doc/fluid/api_cn/layers_cn/logical_xor_cn.rst

@@ -5,6 +5,12 @@ logical_xor
 
 .. py:function:: paddle.fluid.layers.logical_xor(x, y, out=None, name=None)
 
+:alias_main: paddle.logical_xor
+:alias: paddle.logical_xor,paddle.tensor.logical_xor,paddle.tensor.logic.logical_xor
+:old_api: paddle.fluid.layers.logical_xor
+
+
+
 该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑异或运算。
 
 .. math::

doc/fluid/api_cn/layers_cn/logsigmoid_cn.rst

@@ -5,6 +5,12 @@ logsigmoid
 
 .. py:function:: paddle.fluid.layers.logsigmoid(x, name=None)
 
+:alias_main: paddle.nn.functional.logsigmoid
+:alias: paddle.nn.functional.logsigmoid,paddle.nn.functional.activation.logsigmoid
+:old_api: paddle.fluid.layers.logsigmoid
+
+
+
 Logsigmoid激活函数
 
 

doc/fluid/api_cn/layers_cn/lrn_cn.rst

@@ -5,6 +5,12 @@ lrn
 
 .. py:function:: paddle.fluid.layers.lrn(input, n=5, k=1.0, alpha=0.0001, beta=0.75, name=None, data_format='NCHW')
 
+:alias_main: paddle.nn.functional.lrn
+:alias: paddle.nn.functional.lrn,paddle.nn.functional.norm.lrn
+:old_api: paddle.fluid.layers.lrn
+
+
+
 
 该OP实现了局部响应正则化层（Local Response Normalization Layer），用于对局部输入区域正则化，执行一种侧向抑制（lateral inhibition）。更多详情参考： `ImageNet Classification with Deep Convolutional Neural Networks <https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf>`_
 

doc/fluid/api_cn/layers_cn/lstm_cn.rst

@@ -3,10 +3,13 @@
 lstm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function::  paddle.fluid.layers.lstm(input, init_h, init_c, max_len, hidden_size, num_layers, dropout_prob=0.0, is_bidirec=False, is_test=False, name=None, default_initializer=None, seed=-1)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     该OP仅支持 GPU 设备运行
 

doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst

@@ -3,10 +3,13 @@
 lstm_unit
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.lstm_unit(x_t, hidden_t_prev, cell_t_prev, forget_bias=0.0, param_attr=None, bias_attr=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 Long-Short Term Memory（LSTM）循环神经网络计算单元。该OP用于完成单个时间步内LSTM的计算，基于论文 `RECURRENT NEURAL NETWORK REGULARIZATION <http://arxiv.org/abs/1409.2329>`_ 中的描述实现，
 

doc/fluid/api_cn/layers_cn/margin_rank_loss_cn.rst

@@ -5,6 +5,12 @@ margin_rank_loss
 
 .. py:function:: paddle.fluid.layers.margin_rank_loss(label, left, right, margin=0.1, name=None)
 
+:alias_main: paddle.nn.functional.margin_rank_loss
+:alias: paddle.nn.functional.margin_rank_loss,paddle.nn.functional.loss.margin_rank_loss
+:old_api: paddle.fluid.layers.margin_rank_loss
+
+
+
 margin rank loss（间隔排序损失）层。在排序问题中，它可以比较来自排序网络的输入 ``left`` 和输入 ``right`` 的得分。
 
 可用如下等式定义：

doc/fluid/api_cn/layers_cn/matmul_cn.rst

@@ -5,6 +5,9 @@ matmul
 
 .. py:function:: paddle.fluid.layers.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)
 
+
+
+
 输入 ``x`` 和输入 ``y`` 矩阵相乘。
 
 两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。

doc/fluid/api_cn/layers_cn/maxout_cn.rst

@@ -5,6 +5,12 @@ maxout
 
 .. py:function:: paddle.fluid.layers.maxout(x, groups, name=None, axis=1)
 
+:alias_main: paddle.nn.functional.maxout
+:alias: paddle.nn.functional.maxout,paddle.nn.functional.activation.maxout
+:old_api: paddle.fluid.layers.maxout
+
+
+
 假设输入形状为(N, Ci, H, W)，输出形状为(N, Co, H, W)，则 :math:`Co=Ci/groups` 运算公式如下:
 
 .. math::

doc/fluid/api_cn/layers_cn/mean_cn.rst

@@ -5,6 +5,12 @@ mean
 
 .. py:function:: paddle.fluid.layers.mean(x, name=None)
 
+:alias_main: paddle.mean
+:alias: paddle.mean,paddle.tensor.mean,paddle.tensor.stat.mean
+:old_api: paddle.fluid.layers.mean
+
+
+
 计算 ``x`` 所有元素的平均值。
 
 参数：

doc/fluid/api_cn/layers_cn/mean_iou_cn.rst

@@ -5,6 +5,9 @@ mean_iou
 
 .. py:function:: paddle.fluid.layers.mean_iou(input, label, num_classes)
 
+
+
+
 该OP计算均值IOU, 均值IOU（Mean  Intersection-Over-Union）是语义图像分割中的常用的评价指标之一，它首先计算每个类的IOU，然后计算类之间的平均值。IOU定义如下:
 
 .. math::

doc/fluid/api_cn/layers_cn/merge_selected_rows_cn.rst

@@ -5,6 +5,9 @@ merge_selected_rows
 
 .. py:function:: paddle.fluid.layers.merge_selected_rows(x, name=None)
 
+
+
+
 累加合并 `SelectedRows <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/selected_rows.h>`_ ( ``x`` ) 中的重复行，并对行值由小到大重新排序。
 
 参数:

doc/fluid/api_cn/layers_cn/mse_loss_cn.rst

@@ -5,6 +5,12 @@ mse_loss
 
 .. py:function:: paddle.fluid.layers.mse_loss(input,label)
 
+:alias_main: paddle.nn.functional.mse_loss
+:alias: paddle.nn.functional.mse_loss,paddle.nn.functional.loss.mse_loss
+:old_api: paddle.fluid.layers.mse_loss
+
+
+
 该OP用于计算预测值和目标值的均方差误差。
 
 对于预测值input和目标值label，公式为：

doc/fluid/api_cn/layers_cn/mul_cn.rst

@@ -5,6 +5,9 @@ mul
 
 .. py:function:: paddle.fluid.layers.mul(x, y, x_num_col_dims=1, y_num_col_dims=1, name=None)
 
+
+
+
 mul算子
 此运算是用于对输入x和y执行矩阵乘法。
 公式是：

doc/fluid/api_cn/layers_cn/multi_box_head_cn.rst

@@ -3,10 +3,13 @@
 multi_box_head
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.multi_box_head(inputs, image, base_size, num_classes, aspect_ratios, min_ratio=None, max_ratio=None, min_sizes=None, max_sizes=None, steps=None, step_w=None, step_h=None, offset=0.5, variance=[0.1, 0.1, 0.2, 0.2], flip=True, clip=False, kernel_size=1, pad=0, stride=1, name=None, min_max_aspect_ratios_order=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 基于SSD（Single Shot MultiBox Detector）算法，在不同层输入特征上提取先验框、计算回归的坐标位置和分类的置信度，并合并到一起作为输出，具体参数解释和输出格式参考下面说明。更详细信息，请参阅SSD论文 `SSD：Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_ 的2.2节。
 
 参数：

doc/fluid/api_cn/layers_cn/multiclass_nms_cn.rst

@@ -5,6 +5,12 @@ multiclass_nms
 
 .. py:function:: paddle.fluid.layers.multiclass_nms(bboxes, scores, score_threshold, nms_top_k, keep_top_k, nms_threshold=0.3, normalized=True, nms_eta=1.0, background_label=0, name=None)
 
+:alias_main: paddle.nn.functional.multiclass_nms
+:alias: paddle.nn.functional.multiclass_nms,paddle.nn.functional.extension.multiclass_nms
+:old_api: paddle.fluid.layers.multiclass_nms
+
+
+
 **多分类NMS**
 
 该OP用于对边界框（bounding box）和评分（scores）执行多类非极大值抑制（NMS）。

doc/fluid/api_cn/layers_cn/multiplex_cn.rst

@@ -5,6 +5,12 @@ multiplex
 
 .. py:function:: paddle.fluid.layers.multiplex(inputs, index)
 
+:alias_main: paddle.multiplex
+:alias: paddle.multiplex,paddle.tensor.multiplex,paddle.tensor.math.multiplex
+:old_api: paddle.fluid.layers.multiplex
+
+
+
 根据给定的index参数，该OP从每个输入Tensor中选择特定行构造输出Tensor。
 
 设该OP输入包含 :math:`m` 个Tensor，其中 :math:`I_{i}` 代表第i个输入Tensor，:math:`i` 处于区间 :math:`[0,m)`。

doc/fluid/api_cn/layers_cn/natural_exp_decay_cn.rst

@@ -5,6 +5,12 @@ natural_exp_decay
 
 .. py:function:: paddle.fluid.layers.natural_exp_decay(learning_rate, decay_steps, decay_rate, staircase=False)
 
+:alias_main: paddle.nn.functional.natural_exp_decay
+:alias: paddle.nn.functional.natural_exp_decay,paddle.nn.functional.learning_rate.natural_exp_decay
+:old_api: paddle.fluid.layers.natural_exp_decay
+
+
+
 将自然指数衰减运用到初始学习率上。
 
 训练模型时，在训练过程中降低学习率。 自然指数衰减使用自然指数来计算衰减倍率，每 ``decay_steps`` 步衰减倍率的自然指数幂次项上增加 ``decay_rate`` 。

doc/fluid/api_cn/layers_cn/nce_cn.rst

@@ -3,10 +3,13 @@
 nce
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.nce(input, label, num_total_classes, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 计算并返回噪音对比估计损失值（ noise-contrastive estimation training loss）。
 请参考 `Noise-contrastive estimation: A new estimation principle for unnormalized statistical models
 <http://www.jmlr.org/proceedings/papers/v9/gutmann10a/gutmann10a.pdf>`_

doc/fluid/api_cn/layers_cn/noam_decay_cn.rst

@@ -5,6 +5,12 @@ noam_decay
 
 .. py:function:: paddle.fluid.layers.noam_decay(d_model, warmup_steps)
 
+:alias_main: paddle.nn.functional.noam_decay
+:alias: paddle.nn.functional.noam_decay,paddle.nn.functional.learning_rate.noam_decay
+:old_api: paddle.fluid.layers.noam_decay
+
+
+
 Noam衰减方法
 
 noam衰减的numpy实现如下：

doc/fluid/api_cn/layers_cn/not_equal_cn.rst

@@ -5,6 +5,12 @@ not_equal
 
 .. py:function:: paddle.fluid.layers.not_equal(x, y, cond=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` 的逻辑值，使用重载算子 `!=` 可以有相同的计算函数效果。
 
 参数：

doc/fluid/api_cn/layers_cn/npair_loss_cn.rst

@@ -5,6 +5,12 @@ npair_loss
 
 .. py:function:: paddle.fluid.layers.npair_loss(anchor, positive, labels, l2_reg=0.002)
 
+:alias_main: paddle.nn.functional.npair_loss
+:alias: paddle.nn.functional.npair_loss,paddle.nn.functional.loss.npair_loss
+:old_api: paddle.fluid.layers.npair_loss
+
+
+
 **Npair Loss Layer**
 
 参考阅读 `Improved Deep Metric Learning with Multi class N pair Loss Objective <http://www.nec-labs.com/uploads/images/Department-Images/MediaAnalytics/papers/nips16_npairmetriclearning.pdf>`_

doc/fluid/api_cn/layers_cn/one_hot_cn.rst

@@ -5,6 +5,9 @@ one_hot
 
 .. py:function:: paddle.fluid.layers.one_hot(input, depth, allow_out_of_range=False)
 
+
+
+
 **注意：此OP要求输入Tensor shape的最后一维必须为1。此OP将在未来的版本中被移除！推荐使用fluid.** :ref:`cn_api_fluid_one_hot` 。
 
 该OP将输入（input）中的每个id转换为一个one-hot向量，其长度为 ``depth`` ，该id对应的向量维度上的值为1，其余维度的值为0。

doc/fluid/api_cn/layers_cn/ones_cn.rst

@@ -5,6 +5,9 @@ ones
 
 .. py:function:: paddle.fluid.layers.ones(shape,dtype,force_cpu=False)
 
+
+
+
 **ones**
 
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。

doc/fluid/api_cn/layers_cn/ones_like_cn.rst

@@ -5,6 +5,9 @@ ones_like
 
 .. py:function:: paddle.fluid.layers.ones_like(x, out=None)
 
+
+
+
 ones_like
 
 该功能创建一个形状与类型与x相似的张量，初始值为1。

doc/fluid/api_cn/layers_cn/pad2d_cn.rst

@@ -5,6 +5,12 @@ pad2d
 
 .. py:function::  paddle.fluid.layers.pad2d(input, paddings=[0, 0, 0, 0], mode='constant', pad_value=0.0, data_format='NCHW', name=None)
 
+:alias_main: paddle.nn.functional.pad2d
+:alias: paddle.nn.functional.pad2d,paddle.nn.functional.common.pad2d
+:old_api: paddle.fluid.layers.pad2d
+
+
+
 该OP依照 paddings 和 mode 属性对input进行2维 ``pad`` 。
 
 参数：

doc/fluid/api_cn/layers_cn/pad_cn.rst

@@ -5,6 +5,12 @@ pad
 
 .. py:function:: paddle.fluid.layers.pad(x, paddings, pad_value=0.0, name=None)
 
+:alias_main: paddle.nn.functional.pad
+:alias: paddle.nn.functional.pad,paddle.nn.functional.common.pad
+:old_api: paddle.fluid.layers.pad
+
+
+
 该OP在Tensor上填充一个由 ``pad_value`` 给出的常数值，填充宽度由 ``paddings`` 指定。
 其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2*i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2*i+1]`` 表示。
 

doc/fluid/api_cn/layers_cn/pad_constant_like_cn.rst

@@ -5,6 +5,12 @@ pad_constant_like
 
 .. py:function:: paddle.fluid.layers.pad_constant_like(x, y, pad_value=0.0, name=None)
 
+:alias_main: paddle.nn.functional.pad_constant_like
+:alias: paddle.nn.functional.pad_constant_like,paddle.nn.functional.common.pad_constant_like
+:old_api: paddle.fluid.layers.pad_constant_like
+
+
+
 该OP使用 ``pad_value`` 填充 ``y`` ，填充到每个维度值的数量由x和y的形状而指定，((0，x.shape[0] - y.shape[0]), ..., (0, x.shape[i] - y.shape[i]), ..., (0, x.shape[n] - y.shape[n]))是每个维度填充的宽度，对于维度i，填充宽度 ``(0, x.shape[i] - y.shape[i])`` ，表示在y的第i维开头不填充，而在末尾填充 ``x.shape[i] - y.shape[i]`` 个位置。该OP要求y与x具有相同的秩，并且对每个维度i， ``y.shape[i] <= x.shape[i]`` 。
 
 **示例**：

doc/fluid/api_cn/layers_cn/piecewise_decay_cn.rst

@@ -5,6 +5,12 @@ piecewise_decay
 
 .. py:function:: paddle.fluid.layers.piecewise_decay(boundaries,values)
 
+:alias_main: paddle.nn.functional.piecewise_decay
+:alias: paddle.nn.functional.piecewise_decay,paddle.nn.functional.learning_rate.piecewise_decay
+:old_api: paddle.fluid.layers.piecewise_decay
+
+
+
 对初始学习率进行分段衰减。
 
 该算法可用如下代码描述。

doc/fluid/api_cn/layers_cn/pixel_shuffle_cn.rst

@@ -5,6 +5,12 @@ pixel_shuffle
 
 .. py:function:: paddle.fluid.layers.pixel_shuffle(x, upscale_factor)
 
+:alias_main: paddle.nn.functional.pixel_shuffle
+:alias: paddle.nn.functional.pixel_shuffle,paddle.nn.functional.vision.pixel_shuffle
+:old_api: paddle.fluid.layers.pixel_shuffle
+
+
+
 该OP将一个形为[N, C, H, W]的Tensor重新排列成形为 [N, C/r**2, H*r, W*r] 的Tensor。这样做有利于实现步长（stride）为1/r的高效sub-pixel（亚像素）卷积。详见Shi等人在2016年发表的论文 `Real Time Single Image and Video Super Resolution Using an Efficient Sub Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158v2>`_ 。
 
 .. code-block:: text

doc/fluid/api_cn/layers_cn/polygon_box_transform_cn.rst

@@ -5,6 +5,12 @@ polygon_box_transform
 
 .. py:function:: paddle.fluid.layers.polygon_box_transform(input, name=None)
 
+:alias_main: paddle.nn.functional.polygon_box_transform
+:alias: paddle.nn.functional.polygon_box_transform,paddle.nn.functional.extension.polygon_box_transform
+:old_api: paddle.fluid.layers.polygon_box_transform
+
+
+
 **PolygonBoxTransform 算子**
 
 该op用于将偏移坐标改变为真实的坐标。

doc/fluid/api_cn/layers_cn/polynomial_decay_cn.rst

@@ -5,6 +5,12 @@ polynomial_decay
 
 .. py:function:: paddle.fluid.layers.polynomial_decay(learning_rate,decay_steps,end_learning_rate=0.0001,power=1.0,cycle=False)
 
+:alias_main: paddle.nn.functional.polynomial_decay
+:alias: paddle.nn.functional.polynomial_decay,paddle.nn.functional.learning_rate.polynomial_decay
+:old_api: paddle.fluid.layers.polynomial_decay
+
+
+
 对初始学习率使用多项式衰减
 
 .. code-block:: text

doc/fluid/api_cn/layers_cn/pool2d_cn.rst

@@ -5,6 +5,12 @@ pool2d
 
 .. py:function:: paddle.fluid.layers.pool2d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format="NCHW")
 
+:alias_main: paddle.nn.functional.pool2d
+:alias: paddle.nn.functional.pool2d,paddle.nn.functional.pooling.pool2d
+:old_api: paddle.fluid.layers.pool2d
+
+
+
 该OP使用上述输入参数的池化配置，为二维空间池化操作，根据 ``input`` ，池化核大小 ``pool_size`` ，池化类型 ``pool_type`` ，步长 ``pool_stride`` ，填充 ``pool_padding`` 等参数得到输出。
 
 输入 ``input`` 和输出（out）采用NCHW或NHWC格式，N为批大小，C是通道数，H是特征高度，W是特征宽度。

doc/fluid/api_cn/layers_cn/pool3d_cn.rst

@@ -5,6 +5,12 @@ pool3d
 
 .. py:function:: paddle.fluid.layers.pool3d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True, data_format="NCDHW")
 
+:alias_main: paddle.nn.functional.pool3d
+:alias: paddle.nn.functional.pool3d,paddle.nn.functional.pooling.pool3d
+:old_api: paddle.fluid.layers.pool3d
+
+
+
 该OP使用上述输入参数的池化配置，为三维空间池化操作，根据 ``input`` ，池化核大小 ``pool_size`` ，池化类型 ``pool_type`` ，步长 ``pool_stride`` 和填充 ``pool_padding`` 等参数计算输出。
 
 输入 ``input`` 和输出（Out）采用NCDHW或NDHWC格式，其中N是批大小，C是通道数，D，H和W分别是特征的深度，高度和宽度。

doc/fluid/api_cn/layers_cn/pow_cn.rst

@@ -5,6 +5,9 @@ pow
 
 .. py:function:: paddle.fluid.layers.pow(x, factor=1.0, name=None)
 
+
+
+
 该OP是指数激活算子：
 
 .. math::

doc/fluid/api_cn/layers_cn/prelu_cn.rst

@@ -3,10 +3,13 @@
 prelu
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.prelu(x, mode, param_attr=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 等式：
 
 .. math::

doc/fluid/api_cn/layers_cn/prior_box_cn.rst

@@ -4,6 +4,12 @@ prior_box
 -------------------------------
 .. py:function:: paddle.fluid.layers.prior_box(input,image,min_sizes=None,max_sizes=None,aspect_ratios=[1.0],variance=[0.1,0.1,0.2,0.2],flip=False,clip=False,steps=[0.0,0.0],offset=0.5,name=None,min_max_aspect_ratios_order=False)
 
+:alias_main: paddle.nn.functional.prior_box
+:alias: paddle.nn.functional.prior_box,paddle.nn.functional.vision.prior_box
+:old_api: paddle.fluid.layers.prior_box
+
+
+
 该OP为SSD(Single Shot MultiBox Detector)算法生成候选框。输入的每个位产生N个候选框，N由min_sizes,max_sizes和aspect_ratios的数目决定，候选框的尺寸在(min_size,max_size)之间，该尺寸根据aspect_ratios在序列中生成。
 
 参数：

doc/fluid/api_cn/layers_cn/prroi_pool_cn.rst

@@ -5,6 +5,12 @@ prroi_pool
 
 .. py:function:: paddle.fluid.layers.prroi_pool(input, rois, output_channels, spatial_scale, pooled_height, pooled_width, name=None)
 
+:alias_main: paddle.nn.functional.prroi_pool
+:alias: paddle.nn.functional.prroi_pool,paddle.nn.functional.vision.prroi_pool
+:old_api: paddle.fluid.layers.prroi_pool
+
+
+
 PRROIPool运算
 
 精确区域池化方法（Precise region of interest pooling，也称为PRROIPooling）是对输入的 "感兴趣区域"(RoI)执行插值处理，将离散的特征图数据映射到一个连续空间，使用二重积分再求均值的方式实现Pooling。

doc/fluid/api_cn/layers_cn/psroi_pool_cn.rst

@@ -5,6 +5,12 @@ psroi_pool
 
 .. py:function:: paddle.fluid.layers.psroi_pool(input, rois, output_channels, spatial_scale, pooled_height, pooled_width, name=None)
 
+:alias_main: paddle.nn.functional.psroi_pool
+:alias: paddle.nn.functional.psroi_pool,paddle.nn.functional.vision.psroi_pool
+:old_api: paddle.fluid.layers.psroi_pool
+
+
+
 **注意 rois必须为2维LoDTensor，lod_level为1**
 
 该OP执行PSROIPooling运算，是位置敏感的感兴趣区域池化方法（Position sensitive region of interest pooling，也称为PSROIPooling）。输入input是位置敏感的评分图，输入rois是感兴趣区域的位置坐标。PSROIPooling不同于普通ROIPooling的地方在于，输入input特征图的不同通道会跟输出特征图上的位置区域相关联，该方法是在R-FCN模型中首次提出来的，更多详细信息请参阅 https://arxiv.org/abs/1605.06409。

doc/fluid/api_cn/layers_cn/py_func_cn.rst

@@ -3,10 +3,13 @@
 py_func
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 PaddlePaddle Fluid通过py_func在Python端注册OP。py_func的设计原理在于Paddle中的LodTensor与numpy数组可以方便的互相转换，从而可使用Python中的numpy API来自定义一个Python OP。
 
 该自定义的Python OP的前向函数是 ``func``, 反向函数是 ``backward_func`` 。 Paddle将在前向部分调用 ``func`` ，并在反向部分调用 ``backward_func`` （如果 ``backward_func`` 不是None)。 ``x`` 为 ``func`` 的输入，必须为LoDTensor类型； ``out``  为 ``func`` 的输出， 既可以是LoDTensor类型, 也可以是numpy数组。

doc/fluid/api_cn/layers_cn/py_reader_cn.rst

@@ -3,10 +3,13 @@
 py_reader
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.py_reader(capacity, shapes, dtypes, lod_levels=None, name=None, use_double_buffer=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 创建一个在Python端提供数据的reader
 

doc/fluid/api_cn/layers_cn/random_crop_cn.rst

@@ -5,6 +5,12 @@ random_crop
 
 .. py:function:: paddle.fluid.layers.random_crop(x, shape, seed=None)
 
+:alias_main: paddle.nn.functional.random_crop
+:alias: paddle.nn.functional.random_crop,paddle.nn.functional.extension.random_crop
+:old_api: paddle.fluid.layers.random_crop
+
+
+
 该操作对batch中每个实例进行随机裁剪，即每个实例的裁剪位置不同，裁剪位置由均匀分布随机数生成器决定。所有裁剪后的实例都具有相同的维度，由 ``shape`` 参数决定。
 
 参数:

doc/fluid/api_cn/layers_cn/range_cn.rst

@@ -5,6 +5,9 @@ range
 
 .. py:function:: paddle.fluid.layers.range(start, end, step, dtype)
 
+
+
+
 该API根据step均匀分隔给定数值区间[start, end)，并返回该分隔结果。
 
 

doc/fluid/api_cn/layers_cn/rank_cn.rst

@@ -5,6 +5,12 @@ rank
 
 .. py:function::  paddle.fluid.layers.rank(input)
 
+:alias_main: paddle.rank
+:alias: paddle.rank,paddle.tensor.rank,paddle.tensor.attribute.rank
+:old_api: paddle.fluid.layers.rank
+
+
+
 该OP用于计算输入Tensor的维度（秩）。
 
 参数：

doc/fluid/api_cn/layers_cn/rank_loss_cn.rst

@@ -5,6 +5,12 @@ rank_loss
 
 .. py:function::  paddle.fluid.layers.rank_loss(label, left, right, name=None)
 
+:alias_main: paddle.nn.functional.rank_loss
+:alias: paddle.nn.functional.rank_loss,paddle.nn.functional.loss.rank_loss
+:old_api: paddle.fluid.layers.rank_loss
+
+
+
 该OP实现了RankNet模型中的排序损失层。RankNet是一种文档对（pairwise）排序模型，训练样本由一对文档（假设用A、B来表示）组成。标签（假设用P来表示）表示A的排名是否高于B。更多详情请参考：`RankNet <http://icml.cc/2015/wp-content/uploads/2015/06/icml_ranking.pdf>`_
 
 排序损失层有三个输入： :math:`o_i` 、 :math:`o_j` 和 :math:`\tilde{P_{ij}}` ，输入分别表示RankNet模型对文档A、B的输出得分和标签P的值；排序损失层的输入是批输入数据（批大小大于等于1）；标签P的取值可以为： {0, 1} 或 {0, 0.5, 1} ，其中，0.5表示输入文档对排序相同。输入数据的排序损失 :math:`C_{i,j}` 计算过程如下：

doc/fluid/api_cn/layers_cn/read_file_cn.rst

@@ -3,10 +3,13 @@
 read_file
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.read_file(reader)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 从给定的reader中读取数据
 
 reader是一个Variable，它可以是由函数fluid.layers.py_reader()生成的reader，或者是由函数fluid.layers.double_buffer()生成的装饰Variable。

doc/fluid/api_cn/layers_cn/reciprocal_cn.rst

@@ -5,6 +5,12 @@ reciprocal
 
 .. py:function:: paddle.fluid.layers.reciprocal(x, name=None)
 
+:alias_main: paddle.reciprocal
+:alias: paddle.reciprocal,paddle.tensor.reciprocal,paddle.tensor.math.reciprocal
+:old_api: paddle.fluid.layers.reciprocal
+
+
+
 reciprocal 对输入Tensor取倒数
 
 

doc/fluid/api_cn/layers_cn/reduce_all_cn.rst

@@ -5,6 +5,12 @@ reduce_all
 
 .. py:function:: paddle.fluid.layers.reduce_all(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_all
+:alias: paddle.reduce_all,paddle.tensor.reduce_all,paddle.tensor.logic.reduce_all
+:old_api: paddle.fluid.layers.reduce_all
+
+
+
 该OP是对指定维度上的Tensor元素进行与逻辑（&）计算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_any_cn.rst

@@ -5,6 +5,12 @@ reduce_any
 
 .. py:function:: paddle.fluid.layers.reduce_any(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_any
+:alias: paddle.reduce_any,paddle.tensor.reduce_any,paddle.tensor.logic.reduce_any
+:old_api: paddle.fluid.layers.reduce_any
+
+
+
 该OP是对指定维度上的Tensor元素进行或逻辑（|）计算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_max_cn.rst

@@ -5,6 +5,12 @@ reduce_max
 
 .. py:function:: paddle.fluid.layers.reduce_max(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_max
+:alias: paddle.reduce_max,paddle.tensor.reduce_max,paddle.tensor.math.reduce_max
+:old_api: paddle.fluid.layers.reduce_max
+
+
+
 该OP是对指定维度上的Tensor元素求最大值运算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_mean_cn.rst

@@ -5,6 +5,12 @@ reduce_mean
 
 .. py:function:: paddle.fluid.layers.reduce_mean(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_mean
+:alias: paddle.reduce_mean,paddle.tensor.reduce_mean,paddle.tensor.stat.reduce_mean
+:old_api: paddle.fluid.layers.reduce_mean
+
+
+
 该OP是对指定维度上的Tensor元素进行平均值算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_min_cn.rst

@@ -5,6 +5,12 @@ reduce_min
 
 .. py:function:: paddle.fluid.layers.reduce_min(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_min
+:alias: paddle.reduce_min,paddle.tensor.reduce_min,paddle.tensor.math.reduce_min
+:old_api: paddle.fluid.layers.reduce_min
+
+
+
 该OP是对指定维度上的Tensor元素求最小值运算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_prod_cn.rst

@@ -5,6 +5,12 @@ reduce_prod
 
 .. py:function:: paddle.fluid.layers.reduce_prod(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_prod
+:alias: paddle.reduce_prod,paddle.tensor.reduce_prod,paddle.tensor.math.reduce_prod
+:old_api: paddle.fluid.layers.reduce_prod
+
+
+
 该OP是对指定维度上的Tensor元素进行求乘积运算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/reduce_sum_cn.rst

@@ -5,6 +5,12 @@ reduce_sum
 
 .. py:function:: paddle.fluid.layers.reduce_sum(input, dim=None, keep_dim=False, name=None)
 
+:alias_main: paddle.reduce_sum
+:alias: paddle.reduce_sum,paddle.tensor.reduce_sum,paddle.tensor.math.reduce_sum
+:old_api: paddle.fluid.layers.reduce_sum
+
+
+
 该OP是对指定维度上的Tensor元素进行求和运算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/layers_cn/relu6_cn.rst

@@ -5,6 +5,12 @@ relu6
 
 .. py:function:: paddle.fluid.layers.relu6(x, threshold=6.0, name=None)
 
+:alias_main: paddle.nn.functional.relu6
+:alias: paddle.nn.functional.relu6,paddle.nn.functional.activation.relu6
+:old_api: paddle.fluid.layers.relu6
+
+
+
 relu6激活函数
 
 .. math:: out=min(max(0, x), threshold)

doc/fluid/api_cn/layers_cn/relu_cn.rst

@@ -5,6 +5,9 @@ relu
 
 .. py:function:: paddle.fluid.layers.relu(x, name=None)
 
+
+
+
 ReLU（Rectified Linear Unit）激活函数
 
 .. math:: Out=max(0,x)

doc/fluid/api_cn/layers_cn/reorder_lod_tensor_by_rank_cn.rst

@@ -6,6 +6,9 @@ reorder_lod_tensor_by_rank
 .. py:function:: paddle.fluid.layers.reorder_lod_tensor_by_rank(x, rank_table)
 
 
+
+
+
 该OP根据 ``rank_table`` 中提供的 ``LoDRankTable`` 类型的顺序信息来实现对 ``X`` 的重新排列。
 接口参数 ``X`` 是由多个序列(Sequence)组成的的一个批序列（Batch of Sequences）， ``rank_table`` 存储着对batch中序列重新排列的 ``LoDRankTable`` 类型的顺序信息。
 

doc/fluid/api_cn/layers_cn/reshape_cn.rst

@@ -5,6 +5,12 @@ reshape
 
 .. py:function::  paddle.fluid.layers.reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None)
 
+:alias_main: paddle.reshape
+:alias: paddle.reshape,paddle.tensor.reshape,paddle.tensor.manipulation.reshape
+:old_api: paddle.fluid.layers.reshape
+
+
+
 该OP在保持输入 ``x`` 数据不变的情况下，改变 ``x`` 的形状。
 
 目标形状可由 ``shape`` 或 ``actual_shape`` 给出。当两个属性同时被指定时，``actual_shape`` 的优先级高于 ``shape`` ，但此时 ``shape`` 只能是整数列表或元组，且在编译时仍然应该正确地设置 ``shape`` 以保证形状推断。

doc/fluid/api_cn/layers_cn/resize_bilinear_cn.rst

@@ -5,6 +5,12 @@ resize_bilinear
 
 .. py:function:: paddle.fluid.layers.resize_bilinear(input, out_shape=None, scale=None, name=None, actual_shape=None, align_corners=True, align_mode=1, data_format='NCHW')
 
+:alias_main: paddle.nn.functional.resize_bilinear
+:alias: paddle.nn.functional.resize_bilinear,paddle.nn.functional.vision.resize_bilinear
+:old_api: paddle.fluid.layers.resize_bilinear
+
+
+
 **注意:** 参数 ``actual_shape`` 将被弃用，请使用 ``out_shape`` 替代。
 
 该OP应用双向性插值法调整输入图片的大小，输出形状按优先级由actual_shape、out_shape和scale指定。

doc/fluid/api_cn/layers_cn/resize_nearest_cn.rst

@@ -5,6 +5,12 @@ resize_nearest
 
 .. py:function:: paddle.fluid.layers.resize_nearest(input, out_shape=None, scale=None, name=None, actual_shape=None, align_corners=True, data_format='NCHW')
 
+:alias_main: paddle.nn.functional.resize_nearest
+:alias: paddle.nn.functional.resize_nearest,paddle.nn.functional.vision.resize_nearest
+:old_api: paddle.fluid.layers.resize_nearest
+
+
+
 该OP对输入图片进行大小调整，在高度方向宽度方向进行最邻近插值（nearest neighbor interpolation）操作。
 
 输出形状按优先级顺序依据 ``actual_shape`` , ``out_shape`` 和 ``scale`` 而定。

doc/fluid/api_cn/layers_cn/resize_trilinear_cn.rst

@@ -5,6 +5,12 @@ resize_trilinear
 
 .. py:function:: paddle.fluid.layers.resize_trilinear(input, out_shape=None, scale=None, name=None, actual_shape=None, align_corners=True, align_mode=1, data_format='NCDHW')
 
+:alias_main: paddle.nn.functional.resize_trilinear
+:alias: paddle.nn.functional.resize_trilinear,paddle.nn.functional.vision.resize_trilinear
+:old_api: paddle.fluid.layers.resize_trilinear
+
+
+
 **注意:** 参数 ``actual_shape`` 将被弃用，请使用 ``out_shape`` 替代。
 
 该层对输入进行放缩，基于给定的由 ``actual_shape`` , ``out_shape`` , ``scale`` 确定的输出shape，进行三线插值。三线插值是包含三个参数的线性插值方程（D方向，H方向， W方向）,在一个3D格子上进行三个方向的线性插值。更多细节，请参考维基百科：https://en.wikipedia.org/wiki/Trilinear_interpolation

doc/fluid/api_cn/layers_cn/retinanet_detection_output_cn.rst

@@ -5,6 +5,12 @@ retinanet_detection_output
 
 .. py:function:: paddle.fluid.layers.retinanet_detection_output(bboxes, scores, anchors, im_info, score_threshold=0.05, nms_top_k=1000, keep_top_k=100, nms_threshold=0.3, nms_eta=1.0)
 
+:alias_main: paddle.nn.functional.retinanet_detection_output
+:alias: paddle.nn.functional.retinanet_detection_output,paddle.nn.functional.vision.retinanet_detection_output
+:old_api: paddle.fluid.layers.retinanet_detection_output
+
+
+
 在 `RetinaNet <https://arxiv.org/abs/1708.02002>`_ 中，有多个 `FPN <https://arxiv.org/abs/1612.03144>`_ 层会输出用于分类的预测值和位置回归的预测值，该OP通过执行以下步骤将这些预测值转换成最终的检测结果：
 
 1. 在每个FPN层上，先剔除分类预测值小于score_threshold的anchor，然后按分类预测值从大到小排序，选出排名前nms_top_k的anchor，并将这些anchor与其位置回归的预测值做解码操作得到检测框。

doc/fluid/api_cn/layers_cn/retinanet_target_assign_cn.rst

@@ -5,6 +5,12 @@ retinanet_target_assign
 
 .. py:function:: paddle.fluid.layers.retinanet_target_assign(bbox_pred, cls_logits, anchor_box, anchor_var, gt_boxes, gt_labels, is_crowd, im_info, num_classes=1, positive_overlap=0.5, negative_overlap=0.4)
 
+:alias_main: paddle.nn.functional.retinanet_target_assign
+:alias: paddle.nn.functional.retinanet_target_assign,paddle.nn.functional.vision.retinanet_target_assign
+:old_api: paddle.fluid.layers.retinanet_target_assign
+
+
+
 该OP是从输入anchor中找出训练检测模型 `RetinaNet <https://arxiv.org/abs/1708.02002>`_ 所需的正负样本，并为每个正负样本分配用于分类的目标值和位置回归的目标值，同时从全部anchor的类别预测值cls_logits、位置预测值bbox_pred中取出属于各正负样本的部分。
 
 正负样本的查找准则如下：

doc/fluid/api_cn/layers_cn/reverse_cn.rst

@@ -5,6 +5,12 @@ reverse
 
 .. py:function:: paddle.fluid.layers.reverse(x,axis)
 
+:alias_main: paddle.reverse
+:alias: paddle.reverse,paddle.tensor.reverse,paddle.tensor.manipulation.reverse
+:old_api: paddle.fluid.layers.reverse
+
+
+
 **reverse**
 
 该OP对输入Tensor ``x`` 在指定轴 ``axis`` 上进行数据的逆序操作。

doc/fluid/api_cn/layers_cn/rnn_cn.rst

@@ -4,10 +4,13 @@ rnn
 -------------------------------
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:method:: paddle.fluid.layers.rnn(cell, inputs, initial_states=None, sequence_length=None, time_major=False, is_reverse=False, **kwargs)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+    
 
 rnn创建一个由RNNCell :code:`cell` 指定的递归神经网络，该神经网络重复执行 :code:`cell.call()` 直至达到 :code:`inputs` 的最大长度。
 

doc/fluid/api_cn/layers_cn/roi_align_cn.rst

@@ -5,6 +5,12 @@ roi_align
 
 .. py:function:: paddle.fluid.layers.roi_align(input, rois, pooled_height=1, pooled_width=1, spatial_scale=1.0, sampling_ratio=-1, name=None)
 
+:alias_main: paddle.nn.functional.roi_align
+:alias: paddle.nn.functional.roi_align,paddle.nn.functional.vision.roi_align
+:old_api: paddle.fluid.layers.roi_align
+
+
+
 **实现RoIAlign操作。**
 
 Region of Interests align(直译：有意义、有价值选区对齐) 用于实现双线性插值，它可以将不均匀大小的输入

doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst

@@ -5,6 +5,12 @@ roi_perspective_transform
 
 .. py:function:: paddle.fluid.layers.roi_perspective_transform(input, rois, transformed_height, transformed_width, spatial_scale=1.0)
 
+:alias_main: paddle.nn.functional.roi_perspective_transform
+:alias: paddle.nn.functional.roi_perspective_transform,paddle.nn.functional.vision.roi_perspective_transform
+:old_api: paddle.fluid.layers.roi_perspective_transform
+
+
+
 该OP对RoI区域做透视变换，将不规则的RoI区域变成固定大小的矩形区域，透视变换是线性代数里面的一种基础变换。
 
 参数：

doc/fluid/api_cn/layers_cn/roi_pool_cn.rst

@@ -5,6 +5,12 @@ roi_pool
 
 .. py:function:: paddle.fluid.layers.roi_pool(input, rois, pooled_height=1, pooled_width=1, spatial_scale=1.0)
 
+:alias_main: paddle.nn.functional.roi_pool
+:alias: paddle.nn.functional.roi_pool,paddle.nn.functional.vision.roi_pool
+:old_api: paddle.fluid.layers.roi_pool
+
+
+
 
 该OP实现了roi池化操作，对非均匀大小的输入执行最大池化，以获得固定大小的特征映射(例如7*7)。
 

doc/fluid/api_cn/layers_cn/round_cn.rst

@@ -5,6 +5,12 @@ 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将输入中的数值四舍五入到最接近的整数数值。
 

doc/fluid/api_cn/layers_cn/row_conv_cn.rst

@@ -3,10 +3,13 @@
 row_conv
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.row_conv(input, future_context_size, param_attr=None, act=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口为行卷积（Row-convolution operator）或称之为超前卷积（lookahead convolution），最早介绍于DeepSpeech2论文中，论文链接：
 
     `<http://www.cs.cmu.edu/~dyogatam/papers/wang+etal.iclrworkshop2016.pdf>`_

doc/fluid/api_cn/layers_cn/rpn_target_assign_cn.rst

@@ -5,6 +5,12 @@ rpn_target_assign
 
 .. py:function:: paddle.fluid.layers.rpn_target_assign(bbox_pred, cls_logits, anchor_box, anchor_var, gt_boxes, is_crowd, im_info, rpn_batch_size_per_im=256, rpn_straddle_thresh=0.0, rpn_fg_fraction=0.5, rpn_positive_overlap=0.7, rpn_negative_overlap=0.3, use_random=True)
 
+:alias_main: paddle.nn.functional.rpn_target_assign
+:alias: paddle.nn.functional.rpn_target_assign,paddle.nn.functional.extension.rpn_target_assign
+:old_api: paddle.fluid.layers.rpn_target_assign
+
+
+
 该OP用于为anchors分配分类标签和回归标签，以便用这些标签对RPN进行训练。
 
 该OP将anchors分为两种类别，正和负。根据Faster-RCNN的paper，正类别anchor包括以下两种anchor:

doc/fluid/api_cn/layers_cn/rsqrt_cn.rst

@@ -5,6 +5,12 @@ rsqrt
 
 .. py:function:: paddle.fluid.layers.rsqrt(x, name=None)
 
+:alias_main: paddle.rsqrt
+:alias: paddle.rsqrt,paddle.tensor.rsqrt,paddle.tensor.math.rsqrt
+:old_api: paddle.fluid.layers.rsqrt
+
+
+
 该OP为rsqrt激活函数。
 
 注：输入x应确保为非 **0** 值，否则程序会抛异常退出。

doc/fluid/api_cn/layers_cn/sampled_softmax_with_cross_entropy_cn.rst

@@ -5,6 +5,12 @@ sampled_softmax_with_cross_entropy
 
 .. py:function:: paddle.fluid.layers.sampled_softmax_with_cross_entropy(logits, label, num_samples, num_true=1, remove_accidental_hits=True, use_customized_samples=False, customized_samples=None, customized_probabilities=None, seed=0)
 
+:alias_main: paddle.nn.functional.sampled_softmax_with_cross_entropy
+:alias: paddle.nn.functional.sampled_softmax_with_cross_entropy,paddle.nn.functional.loss.sampled_softmax_with_cross_entropy
+:old_api: paddle.fluid.layers.sampled_softmax_with_cross_entropy
+
+
+
 **Sampled Softmax With Cross Entropy Operator**
 
 对于较大的输出类，采样的交叉熵损失Softmax被广泛地用作输出层。该运算符为所有示例采样若干个样本，并计算每行采样张量的SoftMax标准化值，然后计算交叉熵损失。

doc/fluid/api_cn/layers_cn/sampling_id_cn.rst

@@ -5,6 +5,9 @@ sampling_id
 
 .. py:function:: paddle.fluid.layers.sampling_id(x, min=0.0, max=1.0, seed=0, dtype='float32')
 
+
+
+
 该OP从输入的多项分布中进行采样。
 
 参数：

doc/fluid/api_cn/layers_cn/scale_cn.rst

@@ -5,6 +5,12 @@ scale
 
 .. py:function:: paddle.fluid.layers.scale(x, scale=1.0, bias=0.0, bias_after_scale=True, act=None, name=None)
 
+:alias_main: paddle.scale
+:alias: paddle.scale,paddle.tensor.scale,paddle.tensor.math.scale
+:old_api: paddle.fluid.layers.scale
+
+
+
 缩放算子。
 
 对输入Tensor进行缩放和偏置，其公式如下：

doc/fluid/api_cn/layers_cn/scatter_cn.rst

@@ -5,6 +5,12 @@ scatter
 
 .. py:function:: paddle.fluid.layers.scatter(input, index, updates, name=None, overwrite=True)
 
+:alias_main: paddle.scatter
+:alias: paddle.scatter,paddle.tensor.scatter,paddle.tensor.manipulation.scatter
+:old_api: paddle.fluid.layers.scatter
+
+
+
 该OP根据index中的索引值将updates数据更新到input中。
 
 .. code-block:: python

doc/fluid/api_cn/layers_cn/scatter_nd_add_cn.rst

@@ -5,6 +5,12 @@ scatter_nd_add
 
 .. py:function:: paddle.fluid.layers.scatter_nd_add(ref, index, updates, name=None)
 
+:alias_main: paddle.scatter_nd_add
+:alias: paddle.scatter_nd_add,paddle.tensor.scatter_nd_add,paddle.tensor.manipulation.scatter_nd_add
+:old_api: paddle.fluid.layers.scatter_nd_add
+
+
+
 该OP通过对Variable中的单个值或切片应用稀疏加法，从而得到输出的Variable。
 
 :code:`ref` 是维度为 :code:`R` 的张量。 :code:`index` 是维度为 :code:`K` 的张量。因此， :code:`index` 的形状是 :math:`[i_0, i_1, ..., i_{K-2}, Q]` ，其中  :math:`Q \leq R` 。:code:`updates` 是一个维度为 :math:`K - 1 + R - Q` 的张量，它的形状是 :math:`index.shape[:-1] + ref.shape[index.shape[-1]:]` 。

doc/fluid/api_cn/layers_cn/scatter_nd_cn.rst

@@ -5,6 +5,12 @@ scatter_nd
 
 .. py:function:: paddle.fluid.layers.scatter_nd(index, updates, shape, name=None)
 
+:alias_main: paddle.scatter_nd
+:alias: paddle.scatter_nd,paddle.tensor.scatter_nd,paddle.tensor.manipulation.scatter_nd
+:old_api: paddle.fluid.layers.scatter_nd
+
+
+
 该OP根据 :code:`index` ，将 :code:`updates` 添加到一个新的张量中，从而得到输出的Variable。这个操作与 :code:`scatter_nd_add` 类似，除了形状为 :code:`shape` 的张量是通过零初始化的。相应地， :code:`scatter_nd(index, updates, shape)` 等价于 :code:`scatter_nd_add(fluid.layers.zeros(shape, updates.dtype), index, updates)` 。如果 :code:`index` 有重复元素，则将累积相应的更新，因此，由于数值近似问题，索引中重复元素的顺序不同可能会导致不同的输出结果。具体的计算方法可以参见 :code:`scatter_nd_add` 。该OP是 :code:`gather_nd` 的反函数。
 
 参数：

doc/fluid/api_cn/layers_cn/selu_cn.rst

@@ -5,6 +5,12 @@ selu
 
 .. py:function:: paddle.fluid.layers.selu(x, scale=None, alpha=None, name=None)
 
+:alias_main: paddle.nn.functional.selu
+:alias: paddle.nn.functional.selu,paddle.nn.functional.activation.selu
+:old_api: paddle.fluid.layers.selu
+
+
+
 SeLU激活函数，其公式如下：
 
 .. math::

doc/fluid/api_cn/layers_cn/sequence_concat_cn.rst

@@ -3,10 +3,13 @@
 sequence_concat
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_concat(input, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用concat函数（fluid.layers.** :ref:`cn_api_fluid_layers_concat` **）。**
 
 **该OP仅支持LoDTensor** ，通过LoDTensor的LoD信息将输入的多个LoDTensor进行连接（concat），输出连接后的LoDTensor。

doc/fluid/api_cn/layers_cn/sequence_conv_cn.rst

@@ -3,10 +3,13 @@
 sequence_conv
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_conv(input, num_filters, filter_size=3, filter_stride=1, padding=True, padding_start=None, bias_attr=None, param_attr=None, act=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用conv2d函数（fluid.layers.** :ref:`cn_api_fluid_layers_conv2d` **）。**
 
 该OP在给定的卷积参数下（如卷积核数目、卷积核大小等），对输入的变长序列（sequence）LoDTensor进行卷积操作。默认情况下，该OP会自适应地在每个输入序列的两端等长地填充全0数据，以确保卷积后的序列输出长度和输入长度一致。支持通过配置 ``padding_start`` 参数来指定序列填充的行为。

doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst

@@ -3,10 +3,13 @@
 sequence_enumerate
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_enumerate(input, win_size, pad_value=0, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 枚举形状为 ``[d_1, 1]`` 的输入序列所有长度为 ``win_size`` 的子序列，生成一个形状为 ``[d_1, win_size]`` 的新序列，需要时以 ``pad_value`` 填充。
 
 注意,该OP的输入 ``input`` 只能是LodTensor。

doc/fluid/api_cn/layers_cn/sequence_expand_as_cn.rst

@@ -3,10 +3,13 @@
 sequence_expand_as
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_expand_as(x, y, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 Sequence Expand As Layer，该OP根据输入 ``y`` 的第0级lod对输入 ``x`` 进行扩展。当前实现要求 ``y`` 的lod层数（level）必须为1，且 ``x`` 的第一维必须和 ``y`` 的第0层lod大小相同，所以扩展后的LodTensor具有和 ``y`` 相同的lod。扩展结果与输入 ``x`` 的lod无关，所以无需考虑 ``x`` 的lod。
 
 注意，该OP的输入 ``x`` 可以是Tensor或LoDTensor， ``y`` 只能是LodTensor。

doc/fluid/api_cn/layers_cn/sequence_expand_cn.rst

@@ -3,10 +3,13 @@
 sequence_expand
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_expand(x, y, ref_level=-1, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 序列扩张层（Sequence Expand Layer)，根据输入 ``y`` 的第 ``ref_level`` 层lod对输入 ``x`` 进行扩展。 ``x`` 的lod level最多为1，若 ``x`` 的lod level为1，则 ``x`` 的lod大小必须与 ``y`` 的第 ``ref_level`` 层lod大小相等；若 ``x`` 的lod level为0，则 ``x`` 的第一维大小必须与 ``y`` 第 ``ref_level`` 层大小相等。 ``x`` 的秩最少为2，当 ``x`` 的秩大于2时，将被当作是一个二维张量处理。
 
 注意，该OP的输入 ``x`` 可以是Tensor或LodTensor， ``y`` 只能是LodTensor。

doc/fluid/api_cn/layers_cn/sequence_first_step_cn.rst

@@ -3,10 +3,13 @@
 sequence_first_step
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_first_step(input)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP **仅支持LoDTensor类型的输入** ，将对输入的LoDTensor，在最后一层lod_level上，选取其每个序列（sequence）的第一个时间步（time_step）的特征向量作为池化后的输出向量。
 
 ::

doc/fluid/api_cn/layers_cn/sequence_last_step_cn.rst

@@ -3,10 +3,13 @@
 sequence_last_step
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_last_step(input)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该OP **仅支持LoDTensor类型的输入** ，将对输入的LoDTensor，在最后一层lod_level上，选取其每个序列（sequence）的最后一个时间步（time-step）的特征向量作为池化后的输出向量。
 
 ::

doc/fluid/api_cn/layers_cn/sequence_mask_cn.rst

@@ -5,6 +5,9 @@ sequence_mask
 
 .. py:function::  paddle.fluid.layers.sequence_mask(x, maxlen=None, dtype='int64', name=None)
 
+
+
+
 该层根据输入 ``x`` 和 ``maxlen`` 输出一个掩码，数据类型为 ``dtype`` 。
 
 假设 x 是一个形状为 ``[d_1, d_2，…, d_n]`` 的张量， 则输出 y 是一个形状为 ``[d_1, d_2，… ，d_n, maxlen]`` 的掩码，其中:

doc/fluid/api_cn/layers_cn/sequence_pad_cn.rst

@@ -3,10 +3,13 @@
 sequence_pad
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_pad(x,pad_value,maxlen=None,name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 序列填充操作符（Sequence Pad Operator）,该OP将同一batch中的序列填充到一个一致的长度（由 ``maxlen`` 指定）。填充的新元素的值具体由输入 ``pad_value`` 指定，并会添加到每一个序列的末尾，使得他们最终的长度保持一致。最后返回一个Python tuple ``(Out, Length)`` ，其中LodTensor ``Out`` 为填充后的序列，LodTensor ``Length`` 为填充前的原序列长度信息。
 
 注意，该OP的输入 ``x`` 只能是LodTensor。

doc/fluid/api_cn/layers_cn/sequence_pool_cn.rst

@@ -3,10 +3,13 @@
 sequence_pool
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_pool(input, pool_type, is_test=False, pad_value=0.0)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用pool2d函数（fluid.layers.** :ref:`cn_api_fluid_layers_pool2d` **）。**
 
 该OP **仅支持LoDTensor类型的输入** ，将对输入的LoDTensor进行指定方式的池化（pooling）操作。通过指定pool_type参数，将输入的每个序列（sequence）在最后一层lod_level上或时间步（time-step）上对特征进行诸如sum、average、sqrt等池化操作。

doc/fluid/api_cn/layers_cn/sequence_reshape_cn.rst

@@ -3,10 +3,13 @@
 sequence_reshape
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_reshape(input, new_dim)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用reshape函数（fluid.layers.** :ref:`cn_api_fluid_layers_reshape` **）。**
 
 **该OP仅支持LoDTensor** ，在指定 ``new_dim`` 参数下，通过序列原始长度、和原始shape计算出新的shape，以输出包含新维度（new_dim）下的LoDTensor。目前仅支持1-level LoDTensor，请确保(原长度*原维数)可以除以新的维数，且每个序列没有余数。

doc/fluid/api_cn/layers_cn/sequence_reverse_cn.rst

@@ -5,6 +5,9 @@ sequence_reverse
 
 .. py:function:: paddle.fluid.layers.sequence_reverse(x, name=None)
 
+
+
+
 **注意：该OP的输入只能是LoDTensor，如果您需要处理的输入是Tensor类型，请使用reverse函数（fluid.layers.** :ref:`cn_api_fluid_layers_reverse` **）。**
 
 **该OP仅支持LoDTensor** ，对于输入的LoDTensor，在每个序列（sequence）上进行反转。目前仅支持对LoD层次(LoD level)为1的LoDTensor进行反转。该OP在构建反向 :ref:`cn_api_fluid_layers_DynamicRNN` 网络时十分有用。

doc/fluid/api_cn/layers_cn/sequence_scatter_cn.rst

@@ -3,10 +3,13 @@
 sequence_scatter
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_scatter(input, index, updates, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     该OP的输入index，updates必须是LoDTensor。
 

doc/fluid/api_cn/layers_cn/sequence_slice_cn.rst

@@ -3,10 +3,13 @@
 sequence_slice
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_slice(input, offset, length, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **实现Sequence Slice(序列切片)运算**
 
 **该OP输入只能是LoDTensor, 如果您需要处理的是Tensor类型，请使用 :ref:`cn_api_fluid_layers_slice` 。**

doc/fluid/api_cn/layers_cn/sequence_softmax_cn.rst

@@ -3,10 +3,13 @@
 sequence_softmax
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_softmax(input, use_cudnn=False, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     该OP的输入只能是LoDTensor，如果要处理的输入是Tensor类型，请使用 :ref:`cn_api_fluid_layers_softmax`
 

doc/fluid/api_cn/layers_cn/sequence_unpad_cn.rst

@@ -3,10 +3,13 @@
 sequence_unpad
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.sequence_unpad(x, length, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 .. note::
     该OP的输入为Tensor，输出为LoDTensor。该OP用于移除填充元素，与之对应，还存在进行数据填充的OP sequence_pad，详情见： :ref:`cn_api_fluid_layers_sequence_pad`
 

doc/fluid/api_cn/layers_cn/shape_cn.rst

@@ -5,6 +5,12 @@ shape
 
 .. py:function:: paddle.fluid.layers.shape(input)
 
+:alias_main: paddle.shape
+:alias: paddle.shape,paddle.tensor.shape,paddle.tensor.attribute.shape
+:old_api: paddle.fluid.layers.shape
+
+
+
 shape层。
 
 获得输入Tensor的shape。

doc/fluid/api_cn/layers_cn/shard_index_cn.rst

@@ -5,6 +5,12 @@ shard_index
 
 .. py:function:: paddle.fluid.layers.shard_index(input, index_num, nshards, shard_id, ignore_value=-1)
 
+:alias_main: paddle.shard_index
+:alias: paddle.shard_index,paddle.tensor.shard_index,paddle.tensor.manipulation.shard_index
+:old_api: paddle.fluid.layers.shard_index
+
+
+
 该函数对输入的索引根据分片（shard）的偏移量重新计算。
 索引长度被均分为N个分片，如果输入索引所在的分片跟分片ID对应，则该索引以分片的偏移量为界重新计算，否则更新为默认值（ignore_value）。具体计算为：
 ::

doc/fluid/api_cn/layers_cn/shuffle_channel_cn.rst

@@ -5,6 +5,12 @@ shuffle_channel
 
 .. py:function:: paddle.fluid.layers.shuffle_channel(x, group, name=None)
 
+:alias_main: paddle.nn.functional.shuffle_channel
+:alias: paddle.nn.functional.shuffle_channel,paddle.nn.functional.vision.shuffle_channel
+:old_api: paddle.fluid.layers.shuffle_channel
+
+
+
 该OP将输入 ``x`` 的通道混洗重排。 它将每个组中的输入通道分成 ``group`` 个子组，并通过逐一从每个子组中选择元素来获得新的顺序。
 
 请参阅 https://arxiv.org/pdf/1707.01083.pdf

doc/fluid/api_cn/layers_cn/sigmoid_cn.rst

@@ -5,6 +5,9 @@ sigmoid
 
 .. py:function:: paddle.fluid.layers.sigmoid(x, name=None)
 
+
+
+
 sigmoid激活函数
 
 .. math::

doc/fluid/api_cn/layers_cn/sigmoid_cross_entropy_with_logits_cn.rst

@@ -5,6 +5,12 @@ sigmoid_cross_entropy_with_logits
 
 .. py:function:: paddle.fluid.layers.sigmoid_cross_entropy_with_logits(x, label, ignore_index=-100, name=None, normalize=False)
 
+:alias_main: paddle.nn.functional.sigmoid_cross_entropy_with_logits
+:alias: paddle.nn.functional.sigmoid_cross_entropy_with_logits,paddle.nn.functional.loss.sigmoid_cross_entropy_with_logits
+:old_api: paddle.fluid.layers.sigmoid_cross_entropy_with_logits
+
+
+
 在每个类别独立的分类任务中，该OP可以计算按元素的概率误差。可以将其视为预测数据点的标签，其中标签不是互斥的。例如，一篇新闻文章可以同时关于政治，科技，体育或者同时不包含这些内容。
 
 logistic loss可通过下式计算：

doc/fluid/api_cn/layers_cn/sigmoid_focal_loss_cn.rst

@@ -5,6 +5,12 @@ sigmoid_focal_loss
 
 .. py:function:: paddle.fluid.layers.sigmoid_focal_loss(x, label, fg_num, gamma=2.0, alpha=0.25)
 
+:alias_main: paddle.nn.functional.sigmoid_focal_loss
+:alias: paddle.nn.functional.sigmoid_focal_loss,paddle.nn.functional.loss.sigmoid_focal_loss
+:old_api: paddle.fluid.layers.sigmoid_focal_loss
+
+
+
 `Focal Loss <https://arxiv.org/abs/1708.02002>`_ 被提出用于解决计算机视觉任务中前景-背景不平衡的问题。该OP先计算输入x中每个元素的sigmoid值，然后计算sigmoid值与类别目标值label之间的Focal Loss。
 
 Focal Loss的计算过程如下：

doc/fluid/api_cn/layers_cn/sign_cn.rst

@@ -5,6 +5,12 @@ sign
 
 .. py:function:: paddle.fluid.layers.sign(x)
 
+:alias_main: paddle.sign
+:alias: paddle.sign,paddle.tensor.sign,paddle.tensor.math.sign
+:old_api: paddle.fluid.layers.sign
+
+
+
 此OP对输入x中每个元素进行正负判断，并且输出正负判断值：1代表正，-1代表负，0代表零。
 
 参数：

doc/fluid/api_cn/layers_cn/similarity_focus_cn.rst

@@ -5,6 +5,12 @@ similarity_focus
 
 .. py:function:: paddle.fluid.layers.similarity_focus(input, axis, indexes, name=None)
 
+:alias_main: paddle.nn.functional.similarity_focus
+:alias: paddle.nn.functional.similarity_focus,paddle.nn.functional.extension.similarity_focus
+:old_api: paddle.fluid.layers.similarity_focus
+
+
+
 **实现SimilarityFocus(相似度聚焦)运算**
 
 通过以下三个步骤，该层生成一个和输入 ``input`` 同形的 similarity focus mask（相似度聚焦掩码）：

doc/fluid/api_cn/layers_cn/sin_cn.rst

@@ -5,6 +5,9 @@ sin
 
 .. py:function:: paddle.fluid.layers.sin(x, name=None)
 
+
+
+
 计算输入的正弦值。
 
 参数:

doc/fluid/api_cn/layers_cn/size_cn.rst

@@ -5,6 +5,9 @@ size
 
 .. py:function:: paddle.fluid.layers.size(input)
 
+
+
+
 返回张量的单元数量，是一个shape为[1]的int64的张量。
 
 参数:

doc/fluid/api_cn/layers_cn/slice_cn.rst

@@ -5,6 +5,12 @@ slice
 
 .. py:function:: paddle.fluid.layers.slice(input, axes, starts, ends)
 
+:alias_main: paddle.slice
+:alias: paddle.slice,paddle.tensor.slice,paddle.tensor.manipulation.slice
+:old_api: paddle.fluid.layers.slice
+
+
+
 该OP沿多个轴生成 ``input`` 的切片。与numpy类似： https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html 该OP使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对 ``input`` 切片。如果向 ``starts`` 或 ``ends`` 传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以0为初始位置）。如果传递给 ``starts`` 或 ``end`` 的值大于n（维度中的元素数目），则表示n。当切片一个未知数量的维度时，建议传入 ``INT_MAX``。 ``axes`` 、 ``starts`` 和 ``ends`` 三个参数的元素数目必须相等。以下示例将解释切片如何工作：
 
 ::

doc/fluid/api_cn/layers_cn/smooth_l1_cn.rst

@@ -5,6 +5,12 @@ smooth_l1
 
 .. py:function:: paddle.fluid.layers.smooth_l1(x, y, inside_weight=None, outside_weight=None, sigma=None)
 
+:alias_main: paddle.nn.functional.smooth_l1
+:alias: paddle.nn.functional.smooth_l1,paddle.nn.functional.loss.smooth_l1
+:old_api: paddle.fluid.layers.smooth_l1
+
+
+
 该layer计算变量 ``x`` 和 ``y`` 的smooth L1 loss，它以 ``x`` 和 ``y`` 的第一维大小作为批处理大小。对于每个实例，按元素计算smooth L1 loss，然后计算所有loss。输出变量的形状是[batch_size, 1]
 
 

doc/fluid/api_cn/layers_cn/soft_relu_cn.rst

@@ -5,6 +5,12 @@ soft_relu
 
 .. py:function:: paddle.fluid.layers.soft_relu(x, threshold=40.0, name=None)
 
+:alias_main: paddle.nn.functional.soft_relu
+:alias: paddle.nn.functional.soft_relu,paddle.nn.functional.activation.soft_relu
+:old_api: paddle.fluid.layers.soft_relu
+
+
+
 SoftReLU 激活函数.
 
 .. math::   out=ln(1+exp(max(min(x,threshold),-threshold)))

doc/fluid/api_cn/layers_cn/softmax_cn.rst

@@ -5,6 +5,12 @@ softmax
 
 .. py:function:: paddle.fluid.layers.softmax(input, use_cudnn=False, name=None, axis=-1)
 
+:alias_main: paddle.nn.functional.softmax
+:alias: paddle.nn.functional.softmax,paddle.nn.functional.activation.softmax
+:old_api: paddle.fluid.layers.softmax
+
+
+
 该OP实现了softmax层。OP的计算过程如下：
 
 步骤1：输入 ``input`` 的 ``axis`` 维会被置换到最后一维；

doc/fluid/api_cn/layers_cn/softmax_with_cross_entropy_cn.rst

@@ -5,6 +5,12 @@ softmax_with_cross_entropy
 
 .. py:function:: paddle.fluid.layers.softmax_with_cross_entropy(logits, label, soft_label=False, ignore_index=-100, numeric_stable_mode=True, return_softmax=False, axis=-1)
 
+:alias_main: paddle.nn.functional.softmax_with_cross_entropy
+:alias: paddle.nn.functional.softmax_with_cross_entropy,paddle.nn.functional.loss.softmax_with_cross_entropy
+:old_api: paddle.fluid.layers.softmax_with_cross_entropy
+
+
+
 该OP实现了softmax交叉熵损失函数。该函数会将softmax操作、交叉熵损失函数的计算过程进行合并，从而提供了数值上更稳定的梯度值。
 
 因为该运算对 ``logits`` 的 ``axis`` 维执行softmax运算，所以它需要未缩放的 ``logits`` 。该运算不应该对softmax运算的输出进行操作，否则会产生错误的结果。

doc/fluid/api_cn/layers_cn/softplus_cn.rst

@@ -5,6 +5,12 @@ softplus
 
 .. py:function:: paddle.fluid.layers.softplus(x,name=None)
 
+:alias_main: paddle.nn.functional.softplus
+:alias: paddle.nn.functional.softplus,paddle.nn.functional.activation.softplus
+:old_api: paddle.fluid.layers.softplus
+
+
+
 softplus激活函数
 
 .. math::

doc/fluid/api_cn/layers_cn/softshrink_cn.rst

@@ -5,6 +5,12 @@ softshrink
 
 .. py:function:: paddle.fluid.layers.softshrink(x, alpha=None)
 
+:alias_main: paddle.nn.functional.softshrink
+:alias: paddle.nn.functional.softshrink,paddle.nn.functional.activation.softshrink
+:old_api: paddle.fluid.layers.softshrink
+
+
+
 Softshrink激活函数
 
 .. math::

doc/fluid/api_cn/layers_cn/softsign_cn.rst

@@ -5,6 +5,12 @@ softsign
 
 .. py:function:: paddle.fluid.layers.softsign(x,name=None)
 
+:alias_main: paddle.nn.functional.softsign
+:alias: paddle.nn.functional.softsign,paddle.nn.functional.activation.softsign
+:old_api: paddle.fluid.layers.softsign
+
+
+
 
 softsign激活函数
 

doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst

@@ -5,6 +5,12 @@ space_to_depth
 
 .. py:function:: paddle.fluid.layers.space_to_depth(x, blocksize, name=None)
 
+:alias_main: paddle.nn.functional.space_to_depth
+:alias: paddle.nn.functional.space_to_depth,paddle.nn.functional.vision.space_to_depth
+:old_api: paddle.fluid.layers.space_to_depth
+
+
+
 该OP对成块的空间数据进行重组，输出一个输入张量的拷贝，其高度和宽度维度上的值移至通道维度。
 
 重组时，依据 ``blocksize`` 指明的数据块大小, 对形为 ``[batch, channel, height, width]`` 的输入张量进行space_to_depth（广度至深度）运算，生成形为 ``[batch, channel * blocksize * blocksize, height/blocksize, width/blocksize]``  的输出：

doc/fluid/api_cn/layers_cn/spectral_norm_cn.rst

@@ -3,10 +3,13 @@
 spectral_norm
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.spectral_norm(weight, dim=0, power_iters=1, eps=1e-12, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **Spectral Normalization Layer**
 
 该OP用于计算了fc、conv1d、conv2d、conv3d层的权重参数的谱正则值，输入权重参数应分别为2-D, 3-D, 4-D, 5-D张量，输出张量与输入张量shape相同。谱特征值计算方式如下。

doc/fluid/api_cn/layers_cn/split_cn.rst

@@ -5,6 +5,9 @@ split
 
 .. py:function:: paddle.fluid.layers.split(input,num_or_sections,dim=-1,name=None)
 
+
+
+
 该OP将输入Tensor分割成多个子Tensor。
 
 参数：

doc/fluid/api_cn/layers_cn/sqrt_cn.rst

@@ -5,6 +5,9 @@ sqrt
 
 .. py:function:: paddle.fluid.layers.sqrt(x, name=None)
 
+
+
+
 计算输入的算数平方根。
 
 .. math:: out=\sqrt x=x^{1/2}

doc/fluid/api_cn/layers_cn/square_cn.rst

@@ -5,6 +5,12 @@ square
 
 .. py:function:: paddle.fluid.layers.square(x,name=None)
 
+:alias_main: paddle.square
+:alias: paddle.square,paddle.tensor.square,paddle.tensor.math.square
+:old_api: paddle.fluid.layers.square
+
+
+
 该OP执行逐元素取平方运算。
 
 .. math::

doc/fluid/api_cn/layers_cn/square_error_cost_cn.rst

@@ -5,6 +5,12 @@ square_error_cost
 
 .. py:function:: paddle.fluid.layers.square_error_cost(input,label)
 
+:alias_main: paddle.nn.functional.square_error_cost
+:alias: paddle.nn.functional.square_error_cost,paddle.nn.functional.loss.square_error_cost
+:old_api: paddle.fluid.layers.square_error_cost
+
+
+
 该OP用于计算预测值和目标值的方差估计。
 
 对于预测值input和目标值label，公式为：

doc/fluid/api_cn/layers_cn/squeeze_cn.rst

@@ -5,6 +5,9 @@ squeeze
 
 .. py:function:: paddle.fluid.layers.squeeze(input, axes, name=None)
 
+
+
+
 该OP会根据axes压缩输入Tensor的维度。如果指定了axes，则会删除axes中指定的维度，axes指定的维度要等于1。如果没有指定axes，那么所有等于1的维度都会被删除。
 
 - 例1：

doc/fluid/api_cn/layers_cn/ssd_loss_cn.rst

@@ -5,6 +5,12 @@ ssd_loss
 
 .. py:function:: paddle.fluid.layers.ssd_loss(location, confidence, gt_box, gt_label, prior_box, prior_box_var=None, background_label=0, overlap_threshold=0.5, neg_pos_ratio=3.0, neg_overlap=0.5, loc_loss_weight=1.0, conf_loss_weight=1.0, match_type='per_prediction', mining_type='max_negative', normalize=True, sample_size=None)
 
+:alias_main: paddle.nn.functional.ssd_loss
+:alias: paddle.nn.functional.ssd_loss,paddle.nn.functional.loss.ssd_loss
+:old_api: paddle.fluid.layers.ssd_loss
+
+
+
 该OP用于SSD物体检测算法的多窗口损失层
 
 该层用于计算SSD的损失，给定位置偏移预测，置信度预测，候选框和真实框标签，以及难样本挖掘的类型。通过执行以下步骤，返回的损失是本地化损失（或回归损失）和置信度损失（或分类损失）的加权和：

doc/fluid/api_cn/layers_cn/stack_cn.rst

@@ -6,6 +6,9 @@ stack
 .. py:function:: paddle.fluid.layers.stack(x, axis=0)
 
 
+
+
+
 该OP沿 ``axis`` 轴对输入 ``x`` 进行堆叠操作。
 
 - 例1:

doc/fluid/api_cn/layers_cn/stanh_cn.rst

@@ -5,6 +5,12 @@ stanh
 
 .. py:function:: paddle.fluid.layers.stanh(x, scale_a=0.67, scale_b=1.7159, name=None)
 
+:alias_main: paddle.stanh
+:alias: paddle.stanh,paddle.tensor.stanh,paddle.tensor.math.stanh
+:old_api: paddle.fluid.layers.stanh
+
+
+
 STanh 激活算子（STanh Activation Operator.）
 
 .. math::

doc/fluid/api_cn/layers_cn/strided_slice_cn.rst

@@ -3,6 +3,12 @@
 strided_slice
 -------------------------------
 .. py:function:: paddle.fluid.layers.strided_slice(input, axes, starts, ends, strides)
+
+:alias_main: paddle.strided_slice
+:alias: paddle.strided_slice,paddle.tensor.strided_slice,paddle.tensor.manipulation.strided_slice
+:old_api: paddle.fluid.layers.strided_slice
+
+
 strided_slice算子。
 
 该OP沿多个轴生成 ``input`` 的切片，与numpy类似： https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html。该OP使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对 ``input`` 切片。如果向 ``starts`` 或 ``ends`` 传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以0为初始位置）， ``strides`` 表示切片的步长， ``strides`` 如果为负数，则按照反方向进行切片。如果传递给 ``starts`` 或 ``ends`` 的值大于n（维度中的元素数目），则表示n。当切片一个未知数量的维度时，建议传入 ``INT_MAX``。 ``axes`` 、 ``starts`` 和 ``ends`` 以及 ``strides`` 四个参数的元素数目必须相等。以下示例将解释切片如何工作：

doc/fluid/api_cn/layers_cn/sum_cn.rst

@@ -5,6 +5,9 @@ sum
 
 .. py:function:: paddle.fluid.layers.sum(x)
 
+
+
+
 该OP用于对输入的一至多个Tensor或LoDTensor求和。如果输入的是LoDTensor，输出仅与第一个输入共享LoD信息（序列信息）。
 
 例1：

doc/fluid/api_cn/layers_cn/sums_cn.rst

@@ -5,6 +5,12 @@ sums
 
 .. py:function:: paddle.fluid.layers.sums(input,out=None)
 
+:alias_main: paddle.sums
+:alias: paddle.sums,paddle.tensor.sums,paddle.tensor.math.sums
+:old_api: paddle.fluid.layers.sums
+
+
+
 该OP计算多个输入Tensor逐个元素相加的和。
 
 - 示例：3个Tensor求和

doc/fluid/api_cn/layers_cn/swish_cn.rst

@@ -5,6 +5,12 @@ swish
 
 .. py:function:: paddle.fluid.layers.swish(x, beta=1.0, name=None)
 
+:alias_main: paddle.nn.functional.swish
+:alias: paddle.nn.functional.swish,paddle.nn.functional.activation.swish
+:old_api: paddle.fluid.layers.swish
+
+
+
 逐元素计算 Swish 激活函数，参考 `Searching for Activation Functions <https://arxiv.org/abs/1710.05941>`_ 。
 
 .. math::

doc/fluid/api_cn/layers_cn/switch_case_cn.rst

@@ -3,10 +3,16 @@
 switch_case
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.switch_case(branch_index, branch_fns, default=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.switch_case
+:alias: paddle.nn.switch_case,paddle.nn.control_flow.switch_case
+:old_api: paddle.fluid.layers.switch_case
+
+
+
 该OP的运行方式类似于c++的switch/case。
 
 参数：

doc/fluid/api_cn/layers_cn/tanh_cn.rst

@@ -6,6 +6,9 @@ tanh
 .. py:function:: paddle.fluid.layers.tanh(x, name=None)
 
 
+
+
+
 tanh 激活函数
 
 .. math::

doc/fluid/api_cn/layers_cn/tanh_shrink_cn.rst

@@ -5,6 +5,12 @@ tanh_shrink
 
 .. py:function:: paddle.fluid.layers.tanh_shrink(x, name=None)
 
+:alias_main: paddle.nn.functional.tanh_shrink
+:alias: paddle.nn.functional.tanh_shrink,paddle.nn.functional.activation.tanh_shrink
+:old_api: paddle.fluid.layers.tanh_shrink
+
+
+
 tanh_shrink激活函数
 
 .. math::

doc/fluid/api_cn/layers_cn/target_assign_cn.rst

@@ -5,6 +5,12 @@ target_assign
 
 .. py:function:: paddle.fluid.layers.target_assign(input, matched_indices, negative_indices=None, mismatch_value=None, name=None)
 
+:alias_main: paddle.nn.functional.target_assign
+:alias: paddle.nn.functional.target_assign,paddle.nn.functional.extension.target_assign
+:old_api: paddle.fluid.layers.target_assign
+
+
+
 对于每个实例，根据 ``match_indices`` 和 ``negative_indices`` 位置索引, 给输入 ``out`` 和 ``out_weight`` 赋值。输入 ``input`` 和 ``negative_indices`` 均为2-D LoDTensor。假如 ``input`` 中每个实例的行偏移称作lod，该操作计算步骤如下：
 
 1.根据match_indices赋值:

doc/fluid/api_cn/layers_cn/teacher_student_sigmoid_loss_cn.rst

@@ -5,6 +5,12 @@ teacher_student_sigmoid_loss
 
 .. py:function:: paddle.fluid.layers.teacher_student_sigmoid_loss(input, label, soft_max_up_bound=15.0, soft_max_lower_bound=-15.0)
 
+:alias_main: paddle.nn.functional.teacher_student_sigmoid_loss
+:alias: paddle.nn.functional.teacher_student_sigmoid_loss,paddle.nn.functional.loss.teacher_student_sigmoid_loss
+:old_api: paddle.fluid.layers.teacher_student_sigmoid_loss
+
+
+
 **Teacher Student Log Loss Layer（教师--学生对数损失层）**
 
 定制化需求，用于student萃取teacher的值。此图层接受输入预测和目标标签，并返回teacher_student损失。

doc/fluid/api_cn/layers_cn/temporal_shift_cn.rst

@@ -4,6 +4,12 @@ temporal_shift
 -------------------------------
 .. py:function:: paddle.fluid.layers.temporal_shift(x, seg_num, shift_ratio=0.25, name=None)
 
+:alias_main: paddle.nn.functional.temporal_shift
+:alias: paddle.nn.functional.temporal_shift,paddle.nn.functional.extension.temporal_shift
+:old_api: paddle.fluid.layers.temporal_shift
+
+
+
 该OP用于对输入X做时序通道T上的位移操作，为TSM(Temporal Shift Module)中使用的操作。
 
 输入（X）的形状应为[N*T, C, H, W]，N是批大小，T是 ``seg_num`` 指定的时间段号，C是通道号，H和W是特征的高度和宽度。

doc/fluid/api_cn/layers_cn/tensor_array_to_tensor_cn.rst

@@ -5,6 +5,9 @@ tensor_array_to_tensor
 
 .. py:function:: paddle.fluid.layers.tensor_array_to_tensor(input, axis=1, name=None, use_stack=False)
 
+
+
+
 该OP将 ``input`` 这个LoDTensorArray中的所有Tensor沿 ``axis`` 指定的轴进行拼接（concat）或堆叠（stack）。
 
 示例：

doc/fluid/api_cn/layers_cn/thresholded_relu_cn.rst

@@ -5,6 +5,12 @@ thresholded_relu
 
 .. py:function:: paddle.fluid.layers.thresholded_relu(x,threshold=None)
 
+:alias_main: paddle.nn.functional.thresholded_relu
+:alias: paddle.nn.functional.thresholded_relu,paddle.nn.functional.activation.thresholded_relu
+:old_api: paddle.fluid.layers.thresholded_relu
+
+
+
 逐元素计算 ThresholdedRelu激活函数。
 
 .. math::

doc/fluid/api_cn/layers_cn/topk_cn.rst

@@ -4,6 +4,12 @@ topk
 -------------------------------
 .. py:function:: paddle.fluid.layers.topk(input, k, name=None)
 
+:alias_main: paddle.topk
+:alias: paddle.topk,paddle.tensor.topk,paddle.tensor.search.topk
+:old_api: paddle.fluid.layers.topk
+
+
+
 此OP用于查找输入Tensor的最后一维的前k个最大项，返回它们的值和索引。
 如果输入是1-D Tensor，则找到Tensor的前k个最大项，并输出前k个最大项的值和索引。如果输入是更高阶的Tensor，则该OP会基于最后一维计算前k项。
 

doc/fluid/api_cn/layers_cn/transpose_cn.rst

@@ -5,6 +5,12 @@ transpose
 
 .. py:function:: paddle.fluid.layers.transpose(x,perm,name=None)
 
+:alias_main: paddle.transpose
+:alias: paddle.transpose,paddle.tensor.transpose,paddle.tensor.linalg.transpose,paddle.tensor.manipulation.transpose
+:old_api: paddle.fluid.layers.transpose
+
+
+
 该OP根据perm对输入的多维Tensor进行数据重排。返回多维Tensor的第i维对应输入Tensor的perm[i]维。
 
 参数：

doc/fluid/api_cn/layers_cn/unfold_cn.rst

@@ -5,6 +5,12 @@ unfold
 
 .. py:function:: paddle.fluid.layers.unfold(x, kernel_size, strides=1, paddings=0, dilation=1, name=None)
 
+:alias_main: paddle.nn.functional.unfold
+:alias: paddle.nn.functional.unfold,paddle.nn.functional.common.unfold
+:old_api: paddle.fluid.layers.unfold
+
+
+
 该OP实现的功能与卷积中用到的im2col函数一样，通常也被称作为im2col过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的 ``x`` ，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
 
 

doc/fluid/api_cn/layers_cn/uniform_random_cn.rst

@@ -5,6 +5,9 @@ uniform_random
 
 .. py:function:: paddle.fluid.layers.uniform_random(shape, dtype='float32', min=-1.0, max=1.0, seed=0)
 
+
+
+
 该OP使用从范围[min，max)内均匀分布采样的随机值初始化一个Tensor。
 
 ::

doc/fluid/api_cn/layers_cn/unique_cn.rst

@@ -5,6 +5,12 @@ unique
 
 .. py:function:: paddle.fluid.layers.unique(x, dtype='int32')
 
+:alias_main: paddle.unique
+:alias: paddle.unique,paddle.tensor.unique,paddle.tensor.manipulation.unique
+:old_api: paddle.fluid.layers.unique
+
+
+
 unique为 ``x`` 返回一个unique张量和一个指向该unique张量的索引。
 
 参数：

doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst

@@ -4,6 +4,12 @@ unique_with_counts
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.unique_with_counts(x, dtype='int32')
+
+:alias_main: paddle.unique_with_counts
+:alias: paddle.unique_with_counts,paddle.tensor.unique_with_counts,paddle.tensor.manipulation.unique_with_counts
+:old_api: paddle.fluid.layers.unique_with_counts
+
+
 该OP对输入Tensor元素进行去重，获取去重后结果Tensor，同时获取去重后结果在原始输入中的计数Tensor以及在原始输入中的索引Tensor。
 
 注:该OP仅支持 **CPU** ，同时仅支持 **Tensor**

doc/fluid/api_cn/layers_cn/unsqueeze_cn.rst

@@ -5,6 +5,9 @@ unsqueeze
 
 .. py:function:: paddle.fluid.layers.unsqueeze(input, axes, name=None)
 
+
+
+
 该OP向输入（input）的shape中一个或多个位置（axes）插入维度。
 
 - 示例：

doc/fluid/api_cn/layers_cn/unstack_cn.rst

@@ -5,6 +5,12 @@ unstack
 
 .. py:function:: paddle.fluid.layers.unstack(x, axis=0, num=None)
 
+:alias_main: paddle.unstack
+:alias: paddle.unstack,paddle.tensor.unstack,paddle.tensor.manipulation.unstack
+:old_api: paddle.fluid.layers.unstack
+
+
+
 该OP将单个dim为 ``D`` 的Tensor沿 ``axis`` 轴unpack为 ``num`` 个dim为 ``(D-1)`` 的Tensor
 
 参数:

doc/fluid/api_cn/layers_cn/warpctc_cn.rst

@@ -5,6 +5,12 @@ warpctc
 
 .. py:function:: paddle.fluid.layers.warpctc(input, label, blank=0, norm_by_times=False, input_length=None, label_length=None)
 
+:alias_main: paddle.nn.functional.warpctc
+:alias: paddle.nn.functional.warpctc,paddle.nn.functional.extension.warpctc
+:old_api: paddle.fluid.layers.warpctc
+
+
+
 该OP用于计算 `CTC loss <https://www.cs.toronto.edu/~graves/icml_2006.pdf>`_ 。该OP的底层调用了第三方 `baidu-research::warp-ctc <https://github.com/baidu-research/warp-ctc>`_ 的实现。
 
 参数：

doc/fluid/api_cn/layers_cn/where_cn.rst

@@ -5,6 +5,9 @@ where
 
 .. py:function:: paddle.fluid.layers.where(condition)
 
+
+
+
 该OP计算输入元素中为True的元素在输入中的坐标（index）。
         
 参数：

doc/fluid/api_cn/layers_cn/while_loop_cn.rst

@@ -4,10 +4,16 @@ while_loop
 ____________________________________
 
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.layers.while_loop(cond, body, loop_vars, is_test=False, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.nn.while_loop
+:alias: paddle.nn.while_loop,paddle.nn.control_flow.while_loop
+:old_api: paddle.fluid.layers.while_loop
+
+
+
 该API用于实现类似while的循环控制功能，只要循环条件 ``cond`` 的返回值为True，``while_loop`` 则会循环执行循环体 ``body`` ，直到 ``cond`` 的返回值为False。
 
 **注意：**

doc/fluid/api_cn/layers_cn/yolo_box_cn.rst

@@ -5,6 +5,12 @@ yolo_box
 
 .. py:function:: paddle.fluid.layers.yolo_box(x, img_size, anchors, class_num, conf_thresh, downsample_ratio, clip_bbox=True,name=None)
 
+:alias_main: paddle.nn.functional.yolo_box
+:alias: paddle.nn.functional.yolo_box,paddle.nn.functional.vision.yolo_box
+:old_api: paddle.fluid.layers.yolo_box
+
+
+
 
 该运算符基于YOLOv3网络的输出结果，生成YOLO检测框。
 

doc/fluid/api_cn/layers_cn/yolov3_loss_cn.rst

@@ -5,6 +5,12 @@ yolov3_loss
 
 .. py:function:: paddle.fluid.layers.yolov3_loss(x, gt_box, gt_label, anchors, anchor_mask, class_num, ignore_thresh, downsample_ratio, gt_score=None, use_label_smooth=True, name=None)
 
+:alias_main: paddle.nn.functional.yolov3_loss
+:alias: paddle.nn.functional.yolov3_loss,paddle.nn.functional.vision.yolov3_loss
+:old_api: paddle.fluid.layers.yolov3_loss
+
+
+
 该运算通过给定的预测结果和真实框计算yolov3损失。
 
 yolov3 loss前的网络输出形状为[N，C，H，W]，H和W应该相同，用来指定网格(grid)大小。每个网格点预测S个边界框(bounding boxes)，S由每个尺度中 ``anchors`` 簇的个数指定。在第二维（表示通道的维度）中，C的值应为S *（class_num + 5），class_num是源数据集的对象种类数（如coco中为80），另外，除了存储4个边界框位置坐标x，y，w，h，还包括边界框以及每个anchor框的one-hot关键字的置信度得分。

doc/fluid/api_cn/layers_cn/zeros_cn.rst

@@ -5,6 +5,9 @@ zeros
 
 .. py:function:: paddle.fluid.layers.zeros(shape,dtype,force_cpu=False)
 
+
+
+
 **zeros**
 
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。

doc/fluid/api_cn/layers_cn/zeros_like_cn.rst

@@ -6,6 +6,9 @@ zeros_like
 .. py:function:: paddle.fluid.layers.zeros_like(x, out=None)
 
 
+
+
+
 该OP创建一个和x具有相同的形状和数据类型的全零Tensor。
 
 参数：

doc/fluid/api_cn/metrics_cn/Accuracy_cn.rst

@@ -4,6 +4,9 @@ Accuracy
 -------------------------------
 .. py:class:: paddle.fluid.metrics.Accuracy(name=None)
 
+
+
+
 该接口用来计算多个mini-batch的平均准确率。Accuracy对象有两个状态value和weight。Accuracy的定义参照 https://en.wikipedia.org/wiki/Accuracy_and_precision 。
 
 参数:

doc/fluid/api_cn/metrics_cn/Auc_cn.rst

@@ -4,6 +4,9 @@ Auc
 -------------------------------
 .. py:class:: paddle.fluid.metrics.Auc(name, curve='ROC', num_thresholds=4095)
 
+
+
+
 **注意**：目前只用Python实现Auc，可能速度略慢
 
 该接口计算Auc，在二分类(binary classification)中广泛使用。相关定义参考 https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve 。

doc/fluid/api_cn/metrics_cn/ChunkEvaluator_cn.rst

@@ -4,6 +4,9 @@ ChunkEvaluator
 -------------------------------
 
 .. py:class:: paddle.fluid.metrics.ChunkEvaluator(name=None)
+
+
+
 该接口使用mini-batch的chunk_eval累计的counter numbers，来计算准确率、召回率和F1值。ChunkEvaluator有三个状态num_infer_chunks，num_label_chunks和num_correct_chunks，分别对应语块数目、标签中的语块数目、正确识别的语块数目。对于chunking的基础知识，请参考 https://www.aclweb.org/anthology/N01-1025 。ChunkEvalEvaluator计算块检测（chunk detection）的准确率，召回率和F1值，支持IOB, IOE, IOBES和IO标注方案。
 
 参数：

doc/fluid/api_cn/metrics_cn/CompositeMetric_cn.rst

@@ -5,6 +5,9 @@ CompositeMetric
 
 .. py:class:: paddle.fluid.metrics.CompositeMetric(name=None)
 
+
+
+
 创建一个可以容纳若干个评价指标（如F1, accuracy, recall等）的容器，评价指标添加完成后，通过调用eval()方法可自动计算该容器内的所有评价指标。
 
 **注意，只有输入参数列表完全相同的评价指标才可被加入到同一个CompositeMetric实例内。**

doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst

@@ -5,6 +5,9 @@ DetectionMAP
 
 .. py:class:: paddle.fluid.metrics.DetectionMAP(input, gt_label, gt_box, gt_difficult=None, class_num=None, background_label=0, overlap_threshold=0.5, evaluate_difficult=True, ap_version='integral')
 
+
+
+
 该OP用于计算检测网络的平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。
 
 通常步骤如下：

doc/fluid/api_cn/metrics_cn/EditDistance_cn.rst

@@ -5,6 +5,9 @@ EditDistance
 
 .. py:class:: paddle.fluid.metrics.EditDistance(name)
 
+
+
+
 用于管理字符串的编辑距离。编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小编辑操作数（添加、删除或替换）来量化两个字符串（例如单词）彼此不相似的程度一种方法。 参考 https://en.wikipedia.org/wiki/Edit_distance。
 
 **代码示例**

doc/fluid/api_cn/metrics_cn/MetricBase_cn.rst

@@ -5,6 +5,9 @@ MetricBase
 
 .. py:class:: paddle.fluid.metrics.MetricBase(name)
 
+
+
+
 在评估神经网络效果的时候，由于我们常常需要把测试数据切分成mini-batch，并逐次将每个mini-batch送入神经网络进行预测和评估，因此我们每次只能获得当前batch下的评估结果，而并不能一次性获得整个测试集的评估结果。paddle.fluid.metrics正是为了解决这些问题而设计的，大部分paddle.fluid.metrics下的类都具有如下功能：
 
 1. 接受模型对一个batch的预测结果（numpy.array）和这个batch的原始标签（numpy.array）作为输入，并进行特定的计算（如计算准确率，召回率等）。

doc/fluid/api_cn/metrics_cn/Precision_cn.rst

@@ -5,6 +5,9 @@ Precision
 
 .. py:class:: paddle.fluid.metrics.Precision(name=None)
 
+
+
+
 精确率Precision(也称为 positive predictive value,正预测值)是被预测为正样例中实际为正的比例。 https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers 该类管理二分类任务的precision分数。
 
 

doc/fluid/api_cn/metrics_cn/Recall_cn.rst

@@ -5,6 +5,9 @@ Recall
 
 .. py:class:: paddle.fluid.metrics.Recall(name=None)
 
+
+
+
 召回率Recall（也称为敏感度）是指得到的相关实例数占相关实例总数的比例。https://en.wikipedia.org/wiki/Precision_and_recall 该类管理二分类任务的召回率。
 
 **代码示例**

doc/fluid/api_cn/nets_cn/glu_cn.rst

@@ -2,10 +2,13 @@
 
 glu
 -------------------------------
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.nets.glu(input, dim=-1)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 门控线性单元 Gated Linear Units (GLU) 由 :ref:`cn_api_fluid_layers_split` ，:ref:`cn_api_fluid_layers_sigmoid` 和 :ref:`cn_api_fluid_layers_elementwise_mul` 组成。特定的，沿着给定维度将输入拆分成两个大小相同的部分，:math:`a` 和 :math:`b` ，按如下方式计算：
 
 .. math::

doc/fluid/api_cn/nets_cn/img_conv_group_cn.rst

@@ -3,10 +3,13 @@
 img_conv_group
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.nets.img_conv_group(input, conv_num_filter, pool_size, conv_padding=1, conv_filter_size=3, conv_act=None, param_attr=None, conv_with_batchnorm=False, conv_batchnorm_drop_rate=0.0, pool_stride=1, pool_type='max', use_cudnn=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 Image Convolution Group由Convolution2d，BatchNorm，DropOut和Pool2d组成。根据输入参数，img_conv_group将使用Convolution2d，BatchNorm，DropOut对Input进行连续计算，得到最后结果。
 
 参数：

doc/fluid/api_cn/nets_cn/scaled_dot_product_attention_cn.rst

@@ -3,10 +3,13 @@
 scaled_dot_product_attention
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.nets.scaled_dot_product_attention(queries, keys, values, num_heads=1, dropout_rate=0.0)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该接口实现了的基于点积（并进行了缩放）的多头注意力（Multi-Head Attention）机制。attention可以表述为将一个查询（query）和一组键值对（key-value pair）映射为一个输出；Multi-Head Attention则是使用多路进行attention，而且对attention的输入进行了线性变换。公式如下：
 
 

doc/fluid/api_cn/nets_cn/sequence_conv_pool_cn.rst

@@ -3,10 +3,13 @@
 sequence_conv_pool
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max', bias_attr=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **注意：该OP的输入** ``input`` **必须是2维LoDTensor, lod_level为1，如果输入是Tensor，建议使用** :ref:`cn_api_fluid_nets_simple_img_conv_pool` **代替**
 
 该接口由序列卷积( :ref:`cn_api_fluid_layers_sequence_conv` )和池化( :ref:`cn_api_fluid_layers_sequence_pool` )组成

doc/fluid/api_cn/nets_cn/simple_img_conv_pool_cn.rst

@@ -3,10 +3,13 @@
 simple_img_conv_pool
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.nets.simple_img_conv_pool(input, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type='max', global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1, param_attr=None, bias_attr=None, act=None, use_cudnn=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
  ``simple_img_conv_pool`` 由一个conv2d( :ref:`cn_api_fluid_layers_conv2d` )和一个pool2d( :ref:`cn_api_fluid_layers_pool2d` ) OP组成。
 
 参数：

doc/fluid/api_cn/nn_cn/Conv2D_cn.rst

@@ -3,6 +3,11 @@ Conv2D
 
 .. py:class:: paddle.nn.Conv2d(num_channels, num_filters, filter_size, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCHW", dtype="float32")
 
+:alias_main: paddle.nn.Conv2D
+:alias: paddle.nn.Conv2D,paddle.nn.layer.Conv2D,paddle.nn.layer.conv.Conv2D
+
+
+
 **二维卷积层**
 
 该OP是二维卷积层（convolution2D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。

doc/fluid/api_cn/nn_cn/LogSoftmax_cn.rst

@@ -4,6 +4,11 @@ LogSoftmax
 -------------------------------
 .. py:class:: paddle.nn.LogSoftmax(axis=None)
 
+:alias_main: paddle.nn.LogSoftmax
+:alias: paddle.nn.LogSoftmax,paddle.nn.layer.LogSoftmax,paddle.nn.layer.activation.LogSoftmax
+
+
+
 
 **LogSoftmax激活层：**
 

doc/fluid/api_cn/nn_cn/ReLU_cn.rst

@@ -4,6 +4,12 @@ ReLU
 -------------------------------
 .. py:class:: paddle.nn.ReLU(inplace=False)
 
+:alias_main: paddle.nn.ReLU
+:alias: paddle.nn.ReLU,paddle.nn.layer.ReLU,paddle.nn.layer.activation.ReLU
+:update_api: paddle.fluid.layers.relu
+
+
+
 
 **ReLU（Rectified Linear Unit）激活层：**
 

doc/fluid/api_cn/nn_cn/diag_embed_cn.rst

@@ -5,6 +5,11 @@ diag_embed
 
 .. py:function:: paddle.functional.diag_embed(input, offset=0, dim1=-2, dim2=-1):
 
+:alias_main: paddle.nn.functional.diag_embed
+:alias: paddle.nn.functional.diag_embed,paddle.nn.functional.extension.diag_embed
+
+
+
     该 OP 创建一个 Tensor，其在指定的 2D 平面（由 ``dim1`` 和 ``dim2`` 指定）上的对角线由输入 ``input`` 填充。
     默认的，指定的 2D 平面由返回 Tensor 的最后两维组成。
     

doc/fluid/api_cn/nn_cn/interpolate_cn.rst

@@ -5,6 +5,11 @@ Inerpolate
 
 .. py:function:: paddle.nn.functioanl.interpolate(input, out_shape=None, scale=None, name=None, resample='BILINEAR', actual_shape=None, align_corners=True, align_mode=1, data_format='NCHW')
 
+:alias_main: paddle.nn.functional.interpolate
+:alias: paddle.nn.functional.interpolate,paddle.nn.functional.common.interpolate
+
+
+
 **注意:** 参数 ``actual_shape`` 将被弃用，请使用 ``out_shape`` 替代。
 
 该OP用于调整一个batch中图片的大小。

doc/fluid/api_cn/optimizer_cn/AdadeltaOptimizer_cn.rst

@@ -5,6 +5,9 @@ AdadeltaOptimizer
 
 .. py:class:: paddle.fluid.optimizer.AdadeltaOptimizer(learning_rate, epsilon=1.0e-6, rho=0.95, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 **注意：此接口不支持稀疏参数更新。**
 
 Adadelta优化器，具体细节可参考论文 `ADADELTA: AN ADAPTIVE LEARNING RATE METHOD <https://arxiv.org/abs/1212.5701>`_ 。

doc/fluid/api_cn/optimizer_cn/Adadelta_cn.rst

@@ -5,6 +5,9 @@ Adadelta
 
 .. py:attribute::  paddle.fluid.optimizer.Adadelta
 
+
+
+
 ``AdadeltaOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst

@@ -5,6 +5,9 @@ AdagradOptimizer
 
 .. py:class:: paddle.fluid.optimizer.AdagradOptimizer(learning_rate, epsilon=1e-06, parameter_list=None, regularization=None, grad_clip=None, name=None, initial_accumulator_value=0.0)
 
+
+
+
 Adaptive Gradient 优化器(自适应梯度优化器，简称Adagrad)可以针对不同参数样本数不平均的问题，自适应地为各个参数分配不同的学习率。
 
 其参数更新的计算过程如下：

doc/fluid/api_cn/optimizer_cn/Adagrad_cn.rst

@@ -5,6 +5,9 @@ Adagrad
 
 .. py:attribute::  paddle.fluid.optimizer.Adagrad
 
+
+
+
 ``AdagradOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst

@@ -5,6 +5,9 @@ AdamOptimizer
 
 .. py:class:: paddle.fluid.optimizer.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, parameter_list=None, regularization=None, grad_clip=None, name=None, lazy_mode=False)
 
+
+
+
 Adam优化器出自 `Adam论文 <https://arxiv.org/abs/1412.6980>`_ 的第二节，能够利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。
 
 其参数更新的计算公式如下：

doc/fluid/api_cn/optimizer_cn/Adam_cn.rst

@@ -5,6 +5,9 @@ Adam
 
 .. py:attribute::  paddle.fluid.optimizer.Adam
 
+
+
+
 ``AdamOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst

@@ -5,6 +5,9 @@ AdamaxOptimizer
 
 .. py:class:: paddle.fluid.optimizer.AdamaxOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 Adamax优化器是参考 `Adam论文 <https://arxiv.org/abs/1412.6980>`_ 第7节Adamax优化相关内容所实现的。Adamax算法是基于无穷大范数的 `Adam <https://arxiv.org/abs/1412.6980>`_ 算法的一个变种，使学习率更新的算法更加稳定和简单。
 
 其参数更新的计算公式如下:

doc/fluid/api_cn/optimizer_cn/Adamax_cn.rst

@@ -5,6 +5,9 @@ Adamax
 
 .. py:attribute:: paddle.fluid.optimizer.Adamax
 
+
+
+
 ``AdamaxOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst

@@ -3,10 +3,13 @@
 DGCMomentumOptimizer
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.DGCMomentumOptimizer(learning_rate, momentum, rampup_begin_step, rampup_step=1, sparsity=[0.999], use_nesterov=False, local_grad_clip_norm=None, num_trainers=None, regularization=None, grad_clip=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 DGC（深度梯度压缩）Momentum 优化器。原始论文: https://arxiv.org/abs/1712.01887
 
 DGC通过只传送重要梯度（稀疏更新）的方式，即只发送大于给定阈值的梯度，来减少通信带宽使用。

doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst

@@ -5,6 +5,9 @@ DecayedAdagradOptimizer
 
 .. py:class:: paddle.fluid.optimizer.DecayedAdagradOptimizer(learning_rate, decay=0.95, epsilon=1e-06, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 Decayed Adagrad优化器，可以看做是引入了衰减率的 `Adagrad <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 算法，用于解决使用 :ref:`cn_api_fluid_optimizer_AdagradOptimizer` 优化器时，在模型训练中后期学习率急剧下降的问题。
 
 其参数更新的计算公式如下：

doc/fluid/api_cn/optimizer_cn/DecayedAdagrad_cn.rst

@@ -5,6 +5,9 @@ DecayedAdagrad
 
 .. py:attribute::  paddle.fluid.optimizer.DecayedAdagrad
 
+
+
+
 ``DecayedAdagradOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/DpsgdOptimizer_cn.rst

@@ -5,6 +5,9 @@ DpsgdOptimizer
 
 .. py:class:: paddle.fluid.optimizer.DpsgdOptimizer(learning_rate=0.001, clip=0.9, batch_size=0.999, sigma=1e-8)
 
+
+
+
 Dpsgd优化器是参考CCS16论文 `《Deep Learning with Differential Privacy》 <https://arxiv.org/abs/1607.00133>`_ 相关内容实现的。
 
 其参数更新的计算公式如下:

doc/fluid/api_cn/optimizer_cn/Dpsgd_cn.rst

@@ -5,6 +5,9 @@ Dpsgd
 
 .. py:attribute:: paddle.fluid.optimizer.Dpsgd
 
+
+
+
 ``DpsgdOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/ExponentialMovingAverage_cn.rst

@@ -3,10 +3,13 @@
 ExponentialMovingAverage
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.ExponentialMovingAverage(decay=0.999, thres_steps=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 用指数衰减计算参数的滑动平均值。给定参数 :math:`\theta` ，它的指数滑动平均值 (exponential moving average, EMA) 为
 
 .. math::

doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst

@@ -5,6 +5,9 @@ FtrlOptimizer
 
 .. py:class:: paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+ 
 该接口实现FTRL (Follow The Regularized Leader) Optimizer.
 
 FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_)

doc/fluid/api_cn/optimizer_cn/Ftrl_cn.rst

@@ -5,6 +5,9 @@ Ftrl
 
 .. py:attribute::  paddle.fluid.optimizer.Ftrl
 
+
+
+
 ``FtrlOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst

@@ -5,6 +5,9 @@ LambOptimizer
 
 .. py:class:: paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, parameter_list=None, regularization=None, grad_clip=None, exclude_from_weight_decay_fn=None, name=None)
 
+
+
+
 LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
 LAMB的优化器旨在不降低精度的前提下增大训练的批量大小，其支持自适应的逐元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for
 Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf>`_ 。

doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst

@@ -5,6 +5,9 @@ LarsMomentumOptimizer
 
 .. py:class:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 该接口实现LARS支持的Momentum优化器
 
 公式作如下更新：

doc/fluid/api_cn/optimizer_cn/LarsMomentum_cn.rst

@@ -5,6 +5,9 @@ LarsMomentum
 
 .. py:attribute::  paddle.fluid.optimizer.LarsMomentum
 
+
+
+
 ``fluid.optimizer.LarsMomentumOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/LookaheadOptimizer_cn.rst

@@ -3,10 +3,13 @@
 LookaheadOptimizer
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.LookaheadOptimizer(inner_optimizer, alpha=0.5, k=5)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 本类实现了Lookahead优化算法：https://arxiv.org/abs/1907.08610。Lookahead优化算法在内存中保存两部分参数：快参数和慢参数。每个训练步次，inner_optimizer都更新快参数；每隔k个训练步次，Lookahead更新慢参数，如下：
 
 .. math::

doc/fluid/api_cn/optimizer_cn/ModelAverage_cn.rst

@@ -3,10 +3,13 @@
 ModelAverage
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.ModelAverage(average_window_rate, min_average_window=10000, max_average_window=10000, regularization=None, name=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 ModelAverage优化器，在训练过程中累积特定连续的历史Parameters，累积的历史范围可以用传入的average_window参数来控制，在预测时使用平均后的Parameters，通常可以提高预测的精度。
 
 在滑动窗口中累积Parameters的平均值，将结果将保存在临时变量中，通过调用 ``apply()`` 方法可应用于当前模型的Parameters，使用 ``restore()`` 方法恢复当前模型Parameters的值。

doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst

@@ -5,6 +5,9 @@ MomentumOptimizer
 
 .. py:class::  paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, parameter_list=None, use_nesterov=False, regularization=None, grad_clip=None, name=None)
 
+
+
+
 该接口实现含有速度状态的Simple Momentum 优化器
 
 该优化器含有牛顿动量标志，公式更新如下：

doc/fluid/api_cn/optimizer_cn/Momentum_cn.rst

@@ -5,6 +5,9 @@ Momentum
 
 .. py:attribute::  paddle.fluid.optimizer.Momentum
 
+
+
+
 ``MomentumOptimizer`` 的别名
 
 

doc/fluid/api_cn/optimizer_cn/PipelineOptimizer_cn.rst

@@ -3,10 +3,13 @@
 PipelineOptimizer
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.PipelineOptimizer(optimizer, cut_list=None, place_list=None, concurrency_list=None, queue_size=30, sync_steps=1, start_cpu_core_id=0)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 使用流水线模式进行训练。
 Program会根据切分列表cut_list进行分割。如果cut_list的长度是k，则整个program（包括反向部分）将被分割为2*k-1个section。 所以place_list和concurrency_list的长度也必须是2*k-1。 
 

doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst

@@ -5,6 +5,9 @@ RMSPropOptimizer
 
 .. py:class:: paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 该接口实现均方根传播（RMSProp）法，是一种未发表的,自适应学习率的方法。原演示幻灯片中提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张。等式如下所示：
 
 .. math::

doc/fluid/api_cn/optimizer_cn/RecomputeOptimizer_cn.rst

@@ -3,10 +3,13 @@
 RecomputeOptimizer
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.optimizer.RecomputeOptimizer(optimizer)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 通常来讲，一个深度学习的训练流程包含了三个子步骤：首先，运行前向算子来计算Variable和loss的值；其次，运行反向算子来计算参数的梯度；最后，应用优化算法以更新参数值。
 
 在前向运算过程中，反向运算会用到的Variable都会保存在内存中，当模型深度很深时，这会占用大量的内存。

doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst

@@ -5,6 +5,9 @@ SGDOptimizer
 
 .. py:class:: paddle.fluid.optimizer.SGDOptimizer(learning_rate, parameter_list=None, regularization=None, grad_clip=None, name=None)
 
+
+
+
 该接口实现随机梯度下降算法的优化器
 
 .. math::

doc/fluid/api_cn/optimizer_cn/SGD_cn.rst

@@ -5,6 +5,9 @@ SGD
 
 .. py:attribute::  paddle.fluid.optimizer.SGD
 
+
+
+
 ``SGDOptimizer`` 的别名
 
 

doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst

@@ -6,6 +6,9 @@ cuda_profiler
 .. py:function:: paddle.fluid.profiler.cuda_profiler(output_file, output_mode=None, config=None)
 
 
+
+
+
 CUDA性能分析器。该分析器通过调用CUDA运行时编程接口，对CUDA程序进行性能分析，并将分析结果写入输出文件output_file。输出格式由output_mode参数控制，性能分析配置选项由config参数控制。得到输出文件后，用户可使用 `NVIDIA Visual Profiler <https://developer.nvidia.com/nvidia-visual-profiler>`_ 工具来加载这个输出文件以获得可视化结果。
 
 

doc/fluid/api_cn/profiler_cn/profiler_cn.rst

@@ -5,6 +5,9 @@ profiler
 
 .. py:function:: paddle.fluid.profiler.profiler(state, sorted_key=None, profile_path='/tmp/profile', tracer_option='Default')
 
+
+
+
 通用性能分析器 。与 :ref:`cn_api_fluid_profiler_cuda_profiler` 不同，此分析器可用于分析CPU和GPU程序。
 
 参数:

doc/fluid/api_cn/profiler_cn/reset_profiler_cn.rst

@@ -5,6 +5,9 @@ reset_profiler
 
 .. py:function:: paddle.fluid.profiler.reset_profiler()
 
+
+
+
 清除之前的性能分析记录。此接口不能和 :ref:`cn_api_fluid_profiler_cuda_profiler` 一起使用 ，但它可以和 :ref:`cn_api_fluid_profiler_start_profiler` 、:ref:`cn_api_fluid_profiler_stop_profiler` 和 :ref:`cn_api_fluid_profiler_profiler` 一起使用。
 
 **代码示例**

doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst

@@ -5,6 +5,9 @@ start_profiler
 
 .. py:function:: paddle.fluid.profiler.start_profiler(state, tracer_option='Default')
 
+
+
+
 激活使用性能分析器。除了 :ref:`cn_api_fluid_profiler_profiler` 外，用户还可以使用 :ref:`cn_api_fluid_profiler_start_profiler` 和 :ref:`cn_api_fluid_profiler_stop_profiler` 来激活和停止使用性能分析器。
 
 参数:

doc/fluid/api_cn/profiler_cn/stop_profiler_cn.rst

@@ -5,6 +5,9 @@ stop_profiler
 
 .. py:function:: paddle.fluid.profiler.stop_profiler(sorted_key=None, profile_path='/tmp/profile')
 
+
+
+
 停止使用性能分析器。除了 :ref:`cn_api_fluid_profiler_profiler` 外，用户还可以使用 :ref:`cn_api_fluid_profiler_start_profiler` 和 :ref:`cn_api_fluid_profiler_stop_profiler` 来激活和停止使用性能分析器。
 
 参数:

doc/fluid/api_cn/regularizer_cn/L1DecayRegularizer_cn.rst

@@ -5,6 +5,9 @@ L1DecayRegularizer
 
 .. py:class:: paddle.fluid.regularizer.L1DecayRegularizer(regularization_coeff=0.0)
 
+
+
+
 **注意：paddle.fluid.regularizer.L1DecayRegularizer是paddle.fluid.regularizer.L1Decay的别名，推荐使用paddle.fluid.regularizer.L1Decay。**
 
 详见 :ref:`cn_api_fluid_regularizer_L1Decay` 接口的使用文档。

doc/fluid/api_cn/regularizer_cn/L1Decay_cn.rst

@@ -6,6 +6,9 @@ L1Decay
 
 .. py:attribute::   paddle.fluid.regularizer.L1Decay(regularization_coeff=0.0)
 
+
+
+
 L1Decay实现L1权重衰减正则化，用于模型训练，使得权重矩阵稀疏。
 
 该类生成的实例对象，需要设置在 :ref:`cn_api_fluid_ParamAttr` 或者 ``optimizer`` 

doc/fluid/api_cn/regularizer_cn/L2DecayRegularizer_cn.rst

@@ -5,6 +5,9 @@ L2DecayRegularizer
 
 .. py:class:: paddle.fluid.regularizer.L2DecayRegularizer(regularization_coeff=0.0)
 
+
+
+
 **注意：paddle.fluid.regularizer.L2DecayRegularizer是paddle.fluid.regularizer.L2Decay的别名，推荐使用paddle.fluid.regularizer.L2Decay。**
 
 详见 :ref:`cn_api_fluid_regularizer_L2Decay` 接口的使用文档。

doc/fluid/api_cn/regularizer_cn/L2Decay_cn.rst

@@ -5,6 +5,9 @@ L2Decay
 
 .. py:attribute::   paddle.fluid.regularizer.L2Decay
 
+
+
+
 L2Decay实现L2权重衰减正则化，用于模型训练，有助于防止模型对训练数据过拟合。
 
 该类生成的实例对象，需要设置在 :ref:`cn_api_fluid_ParamAttr` 或者 ``optimizer`` 

doc/fluid/api_cn/tensor_cn/add_cn.rst

@@ -5,6 +5,12 @@ add
 
 .. py:function:: paddle.add(x, y, alpha=1, out=None, name=None)
 
+:alias_main: paddle.add
+:alias: paddle.add,paddle.tensor.add,paddle.tensor.math.add
+:update_api: paddle.fluid.layers.elementwise_add
+
+
+
 该OP是逐元素相加算子，输入 ``x`` 与输入 ``y`` 逐元素相加，并将各个位置的输出元素保存到返回结果中。
 
 等式为：

doc/fluid/api_cn/tensor_cn/addcmul_cn.rst

@@ -5,6 +5,11 @@ addcmul
 
 .. py:function:: paddle.addcmul(input, tensor1, tensor2, value=1.0, out=None, name=None)
 
+:alias_main: paddle.addcmul
+:alias: paddle.addcmul,paddle.tensor.addcmul,paddle.tensor.math.addcmul
+
+
+
 计算tensor1和tensor2的逐元素乘积，然后将结果乘以标量value，再加到input上输出。其中input, tensor1, tensor2的维度必须是可广播的。
 
 计算过程的公式为：

doc/fluid/api_cn/tensor_cn/addmm_cn.rst

@@ -6,6 +6,11 @@ addmm
 
 .. py:function:: paddle.addmm(input, x, y, alpha=1.0, beta=1.0, name=None)
 
+:alias_main: paddle.addmm
+:alias: paddle.addmm,paddle.tensor.addmm,paddle.tensor.math.addmm
+
+
+
 计算x和y的乘积，将结果乘以标量alpha，再加上input与beta的乘积，得到输出。其中input与x、y乘积的维度必须是可广播的。
 
 计算过程的公式为：

doc/fluid/api_cn/tensor_cn/allclose_cn.rst

@@ -5,6 +5,11 @@ allclose
 
 .. py:function:: paddle.allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False, name=None)
 
+:alias_main: paddle.allclose
+:alias: paddle.allclose,paddle.tensor.allclose,paddle.tensor.logic.allclose
+
+
+
 逐个检查input和other的所有元素是否均满足如下条件：
 
 ..  math::

doc/fluid/api_cn/tensor_cn/arange_cn.rst

@@ -5,6 +5,12 @@ arange
 
 .. py:function:: paddle.tensor.arange(start, end, step=1, dtype=None, name=None)
 
+:alias_main: paddle.arange
+:alias: paddle.arange,paddle.tensor.arange,paddle.tensor.creation.arange
+:update_api: paddle.fluid.layers.range
+
+
+
 该API根据step均匀分隔给定数值区间[start, end)，并返回该分隔结果。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/argmax_cn.rst

@@ -5,6 +5,12 @@ argmax
 
 .. py:function:: paddle.argmax(input, axis=None, dtype=None, out=None, keepdims=False, name=None)
 
+:alias_main: paddle.argmax
+:alias: paddle.argmax,paddle.tensor.argmax,paddle.tensor.search.argmax
+:update_api: paddle.fluid.layers.argmax
+
+
+
 
 该OP沿 ``axis`` 计算输入 ``input`` 的最大元素的索引。
 

doc/fluid/api_cn/tensor_cn/bmm_cn.rst

@@ -5,6 +5,11 @@ bmm
 
 .. py:function:: paddle.tensor.bmm(x, y, name=None):
 
+:alias_main: paddle.bmm
+:alias: paddle.bmm,paddle.tensor.bmm,paddle.tensor.linalg.bmm
+
+
+
 对输入x及输入y进行矩阵相乘。
 
 两个输入的维度必须等于3，并且矩阵x和矩阵y的第一维必须相等

doc/fluid/api_cn/tensor_cn/clamp_cn.rst

@@ -5,6 +5,11 @@ clamp
 
 .. py:function:: paddle.clamp(input, min=None, max=None, output=None, name=None)
 
+:alias_main: paddle.clamp
+:alias: paddle.clamp,paddle.tensor.clamp,paddle.tensor.math.clamp
+
+
+
 该OP将输入的所有元素进行剪裁，使得输出元素限制在[min, max]内，具体公式如下：
 
 .. math::

doc/fluid/api_cn/tensor_cn/cross_cn.rst

@@ -5,6 +5,11 @@ cross
 
 .. py:function:: paddle.cross(input, other, dim=None)
 
+:alias_main: paddle.cross
+:alias: paddle.cross,paddle.tensor.cross,paddle.tensor.linalg.cross
+
+
+
 该OP返回在 ``dim`` 维度上，两个张量 ``input`` 和 ``other`` 的向量积（叉积）。 ``input`` 和 ``other`` 必须有相同的形状，
 且指定的 ``dim`` 维上 ``size`` 必须为3，如果 ``dim`` 未指定，默认选取第一个 ``size`` 等于3的维度。
         

doc/fluid/api_cn/tensor_cn/dist_cn.rst

@@ -5,6 +5,11 @@ dist
 
 .. py:function:: paddle.tensor.linalg.dist(x, y, p=2)
 
+:alias_main: paddle.dist
+:alias: paddle.dist,paddle.tensor.dist,paddle.tensor.linalg.dist
+
+
+
 该OP用于计算 `(x-y)` 的 p 范数（p-norm），需要注意这不是严格意义上的范数，仅作为距离的度量。输入 `x` 和 `y` 的形状（shape）必须是可广播的（broadcastable）。其含义如下，详情请参考 `numpy的广播概念 <https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html>`_ ：
 
 - 每个输入都至少有1维

doc/fluid/api_cn/tensor_cn/div_cn.rst

@@ -5,6 +5,12 @@ div
 
 .. py:function:: paddle.div(x, y, out=None, name=None)
 
+:alias_main: paddle.div
+:alias: paddle.div,paddle.tensor.div,paddle.tensor.math.div
+:update_api: paddle.fluid.layers.elementwise_div
+
+
+
 该OP是逐元素相除算子，输入 ``x`` 与输入 ``y`` 逐元素相除，并将各个位置的输出元素保存到返回结果中。
 
 等式是：

doc/fluid/api_cn/tensor_cn/dot_cn.rst

@@ -5,6 +5,11 @@ dot
 
 .. py:function:: paddle.tensor.linalg.dot(x, y, name=None)
 
+:alias_main: paddle.dot
+:alias: paddle.dot,paddle.tensor.dot,paddle.tensor.linalg.dot
+
+
+
 该OP计算向量的内积
 
 .. note::

doc/fluid/api_cn/tensor_cn/elementwise_equal_cn.rst

@@ -5,6 +5,12 @@ elementwise_equal
 
 .. py:function:: paddle.elementwise_equal(x, y, name=None)
 
+:alias_main: paddle.elementwise_equal
+:alias: paddle.elementwise_equal,paddle.tensor.elementwise_equal,paddle.tensor.logic.elementwise_equal
+:update_api: paddle.fluid.layers.equal
+
+
+
 该OP返回 :math:`x==y` 逐元素比较x和y是否相等。
 
 参数：

doc/fluid/api_cn/tensor_cn/elementwise_sum_cn.rst

@@ -5,6 +5,11 @@ elementwise_sum
 
 .. py:function:: paddle.elementwise_sum(inputs, name=None)
 
+:alias_main: paddle.elementwise_sum
+:alias: paddle.elementwise_sum,paddle.tensor.elementwise_sum,paddle.tensor.math.elementwise_sum
+
+
+
 该OP用于对输入的一至多个Tensor或LoDTensor求和。如果输入的是LoDTensor，输出仅与第一个输入共享LoD信息（序列信息）。
 
 例1：

doc/fluid/api_cn/tensor_cn/equal_cn.rst

@@ -4,6 +4,11 @@ equal
 -------------------------------
 .. py:function:: paddle.equal(x, y, axis=-1, name=None)
 
+:alias_main: paddle.equal
+:alias: paddle.equal,paddle.tensor.equal,paddle.tensor.logic.equal
+
+
+
 该OP返回 :math:`x==y` 逐元素比较x和y是否相等，所有的元素都相同则返回True，否则返回False。
 
 参数：

doc/fluid/api_cn/tensor_cn/flip_cn.rst

@@ -5,6 +5,11 @@ flip
 
 .. py:function:: paddle.flip(input, dims, name=None):
 
+:alias_main: paddle.flip
+:alias: paddle.flip,paddle.tensor.flip,paddle.tensor.manipulation.flip
+
+
+
 该OP沿指定轴反转n维tensor.
 
 参数：

doc/fluid/api_cn/tensor_cn/full_cn.rst

@@ -5,6 +5,12 @@ full
 
 .. py:function:: paddle.full(shape, fill_value, out=None, dtype=None, device=None, stop_gradient=True, name=None)
 
+:alias_main: paddle.full
+:alias: paddle.full,paddle.tensor.full,paddle.tensor.creation.full
+:update_api: paddle.fluid.layers.fill_constant
+
+
+
 该OP创建一个和具有相同的形状和数据类型的Tensor，其中元素值均为fill_value。
 
 参数：

doc/fluid/api_cn/tensor_cn/full_like_cn.rst

@@ -5,6 +5,11 @@ full_like
 
 .. py:function:: paddle.full_like(input, fill_value, out=None, dtype=None, device=None, stop_gradient=True, name=None)
 
+:alias_main: paddle.full_like
+:alias: paddle.full_like,paddle.tensor.full_like,paddle.tensor.creation.full_like
+
+
+
 该OP创建一个和input具有相同的形状和数据类型的Tensor，其中元素值均为fill_value。
 
 参数：

doc/fluid/api_cn/tensor_cn/gather_cn.rst

@@ -4,6 +4,12 @@ gather
 
 .. py:function:: paddle.tensor.gather(input, index, overwrite=True)
 
+:alias_main: paddle.gather
+:alias: paddle.gather,paddle.tensor.gather,paddle.tensor.manipulation.gather
+:update_api: paddle.fluid.layers.gather
+
+
+
 根据索引 index 获取输入（input）的最外层维度的条目，并将它们拼接在一起。
 
 .. math::

doc/fluid/api_cn/tensor_cn/index_sample_cn.rst

@@ -5,6 +5,11 @@ index_sample
 
 .. py:function:: paddle.index_sample(x, index)
 
+:alias_main: paddle.index_sample
+:alias: paddle.index_sample,paddle.tensor.index_sample,paddle.tensor.search.index_sample
+
+
+
 该OP实现对输入 ``x`` 中的元素进行批量抽样，取 ``index`` 指定的对应下标的元素，按index中出现的先后顺序组织，填充为一个新的张量。
 
 该OP中 ``x`` 与 ``index`` 都是 ``2-D`` 张量。 ``index`` 的第一维度与输入 ``x`` 的第一维度必须相同， ``index`` 的第二维度没有大小要求，可以重复索引相同下标元素。

doc/fluid/api_cn/tensor_cn/index_select_cn.rst

@@ -5,6 +5,11 @@ index_select
 
 .. py:function:: paddle.index_select(input, index, dim=0)
 
+:alias_main: paddle.index_select
+:alias: paddle.index_select,paddle.tensor.index_select,paddle.tensor.search.index_select
+
+
+
 该OP沿着指定维度 ``dim`` 对输入 ``input`` 进行索引，取 ``index`` 中指定的相应项，然后返回到一个新的张量。这里 ``index`` 是一个 ``1-D`` 张量。除 ``dim`` 维外，返回的张量其余维度大小同输入 ``input`` ， ``dim`` 维大小等于 ``index`` 的大小。
         
 **参数**：

doc/fluid/api_cn/tensor_cn/inverse_cn.rst

@@ -5,6 +5,11 @@ inverse
 
 .. py:function:: paddle.inverse(input, out=None, name=None)
 
+:alias_main: paddle.inverse
+:alias: paddle.inverse,paddle.tensor.inverse,paddle.tensor.math.inverse
+
+
+
 计算方阵的逆。方阵是行数和列数相等的矩阵。输入可以是一个方阵（2-D张量），或者是批次方阵（维数大于2时）。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/kron_cn.rst

@@ -5,6 +5,11 @@ kron
 
 .. py:function:: paddle.tensor.kron(x, y, out=None, name=None)
 
+:alias_main: paddle.kron
+:alias: paddle.kron,paddle.tensor.kron,paddle.tensor.math.kron
+
+
+
 
 Kronecker Product 算子。
 

doc/fluid/api_cn/tensor_cn/linspace_cn.rst

@@ -5,6 +5,12 @@ linspace
 
 .. py:function:: paddle.linspace(start, stop, num, dtype, out=None, device=None, name=None)
 
+:alias_main: paddle.linspace
+:alias: paddle.linspace,paddle.tensor.linspace,paddle.tensor.creation.linspace
+:update_api: paddle.fluid.layers.linspace
+
+
+
 该OP在给定区间内返回固定数目的均匀间隔的值。
 
 **注意：该OP不进行梯度计算**

doc/fluid/api_cn/tensor_cn/log1p_cn.rst

@@ -5,6 +5,11 @@ log1p
 
 .. py:function:: paddle.tensor.log1p(x, out=None, name=None)
 
+:alias_main: paddle.log1p
+:alias: paddle.log1p,paddle.tensor.log1p,paddle.tensor.math.log1p
+
+
+
 
 该OP计算Log1p（加一的自然对数）结果。
 

doc/fluid/api_cn/tensor_cn/logsumexp_cn.rst

@@ -5,6 +5,11 @@ logsumexp
 
 .. py:function:: paddle.tensor.math.logsumexp(x, dim=None, keepdim=False, out=None, name=None)
 
+:alias_main: paddle.logsumexp
+:alias: paddle.logsumexp,paddle.tensor.logsumexp,paddle.tensor.math.logsumexp
+
+
+
 该OP对输入Tensor的元素以e为底做指数运算，然后根据指定维度做求和之后取自然对数
 
 .. math::

doc/fluid/api_cn/tensor_cn/matmul_cn.rst

@@ -5,6 +5,11 @@ matmul
 
 .. py:function:: paddle.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)
 
+:alias_main: paddle.matmul
+:alias: paddle.matmul,paddle.tensor.matmul,paddle.tensor.linalg.matmul
+
+
+
 输入 ``x`` 和输入 ``y`` 矩阵相乘。
 
 两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。

doc/fluid/api_cn/tensor_cn/max_cn.rst

@@ -6,6 +6,12 @@ max
 
 .. py:function:: paddle.tensor.max(input, dim=None, keep_dim=False, out=None, name=None)
 
+:alias_main: paddle.max
+:alias: paddle.max,paddle.tensor.max,paddle.tensor.math.max
+:update_api: paddle.fluid.layers.reduce_max
+
+
+
 该OP是对指定维度上的Tensor元素求最大值运算，并输出相应的计算结果。等价于 :ref:`cn_api_fluid_layers_reduce_max`
 
 参数：

doc/fluid/api_cn/tensor_cn/meshgrid_cn.rst

@@ -6,6 +6,11 @@ meshgrid
 
 .. py:function:: paddle.tensor.meshgrid(input, name=None)
 
+:alias_main: paddle.meshgrid
+:alias: paddle.meshgrid,paddle.tensor.meshgrid,paddle.tensor.creation.meshgrid
+
+
+
 该OP的输入是tensor list, 包含 k 个一维Tensor，对每个Tensor做扩充操作，输出 k 个 k 维tensor。
 
 参数：

doc/fluid/api_cn/tensor_cn/min_cn.rst

@@ -5,6 +5,12 @@ min
 
 .. py:function:: paddle.tensor.min(input, dim=None, keep_dim=False, out=None, name=None)
 
+:alias_main: paddle.min
+:alias: paddle.min,paddle.tensor.min,paddle.tensor.math.min
+:update_api: paddle.fluid.layers.reduce_min
+
+
+
 该OP是对指定维度上的Tensor元素求最小值运算，并输出相应的计算结果。等价于 :ref:`cn_api_fluid_layers_reduce_min`
 
 参数：

doc/fluid/api_cn/tensor_cn/mm_cn.rst

@@ -5,6 +5,12 @@ mm
 
 .. py:function:: paddle.mm(input, mat2, out=None, name=None)
 
+:alias_main: paddle.mm
+:alias: paddle.mm,paddle.tensor.mm,paddle.tensor.math.mm
+:update_api: paddle.fluid.layers.matmul
+
+
+
 用于两个输入矩阵的相乘。
 
 两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。

doc/fluid/api_cn/tensor_cn/mul_cn.rst

@@ -5,6 +5,12 @@ mul
 
 .. py:function:: paddle.mul(x, y, x_num_col_dims=1, y_num_col_dims=1, out=None, name=None)
 
+:alias_main: paddle.mul
+:alias: paddle.mul,paddle.tensor.mul,paddle.tensor.math.mul
+:update_api: paddle.fluid.layers.mul
+
+
+
 
 mul算子
 此运算是用于对输入x和y执行矩阵乘法。

doc/fluid/api_cn/tensor_cn/nonzero_cn.rst

@@ -5,6 +5,11 @@ nonzero
 
 .. py:function:: paddle.nonzero(input, as_tuple=False)
 
+:alias_main: paddle.nonzero
+:alias: paddle.nonzero,paddle.tensor.nonzero,paddle.tensor.search.nonzero
+
+
+
 该OP返回输入 ``input`` 中非零元素的坐标。如果输入 ``input`` 有 ``n`` 维，共包含 ``z`` 个非零元素，当 ``as_tuple = False`` 时，
 返回结果是一个 ``shape`` 等于 ``[z x n]`` 的 ``Tensor`` , 第 ``i`` 行代表输入中第 ``i`` 个非零元素的坐标；当 ``as_tuple = True`` 时，
 返回结果是由 ``n`` 个大小为 ``z`` 的 ``1-D Tensor`` 构成的元组，第 ``i`` 个 ``1-D Tensor`` 记录输入的非零元素在第 ``i`` 维的坐标。

doc/fluid/api_cn/tensor_cn/norm_cn.rst

@@ -5,6 +5,12 @@ norm
 
 .. py:function:: paddle.norm(input, p='fro', axis=None, keepdim=False, out=None, name=None):
 
+:alias_main: paddle.norm
+:alias: paddle.norm,paddle.tensor.norm,paddle.tensor.linalg.norm
+:update_api: paddle.fluid.layers.l2_normalize
+
+
+
 该OP将计算给定Tensor的矩阵范数（Frobenius 范数）和向量范数（向量1范数、2范数、或者通常的p范数）.
 
 参数：

doc/fluid/api_cn/tensor_cn/ones_cn.rst

@@ -5,6 +5,12 @@ ones
 
 .. py:function:: paddle.ones(shape, dtype, out=None, device=None)
 
+:alias_main: paddle.ones
+:alias: paddle.ones,paddle.tensor.ones,paddle.tensor.creation.ones
+:update_api: paddle.fluid.layers.ones
+
+
+
 
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor。
 

doc/fluid/api_cn/tensor_cn/ones_like_cn.rst

@@ -5,6 +5,12 @@ ones_like
 
 .. py:function:: paddle.ones_like(input, dtype=None, device=None, name=None)
 
+:alias_main: paddle.ones_like
+:alias: paddle.ones_like,paddle.tensor.ones_like,paddle.tensor.creation.ones_like
+:update_api: paddle.fluid.layers.ones_like
+
+
+
 
 该OP创建一个和input具有相同的形状和数据类型的全1Tensor。
 

doc/fluid/api_cn/tensor_cn/pow_cn.rst

@@ -5,6 +5,12 @@ pow
 
 .. py:function:: paddle.pow(input, exponent, out=None, name=None):
 
+:alias_main: paddle.pow
+:alias: paddle.pow,paddle.tensor.pow,paddle.tensor.math.pow
+:update_api: paddle.fluid.layers.pow
+
+
+
 该OP是指数激活算子：
 
 .. math::

doc/fluid/api_cn/tensor_cn/randint_cn.rst

@@ -5,6 +5,11 @@ randint
 
 .. py:function:: paddle.randint(low, high=None, shape=None, out=None, dtype=None, device=None, stop_gradient=False, seed=0, name=None)
 
+:alias_main: paddle.randint
+:alias: paddle.randint,paddle.tensor.randint,paddle.tensor.random.randint
+
+
+
 该OP使用从区间[low，high)内均匀分布采样的随机整数初始化一个Tensor。当high为None时（默认），均匀采样的区间为[0,low)。
 
 参数：

doc/fluid/api_cn/tensor_cn/randn_cn.rst

@@ -5,6 +5,11 @@ randn
 
 .. py:function:: paddle.tensor.random.randn(shape, out=None, dtype=None, device=None, stop_gradient=True, name=None)
 
+:alias_main: paddle.randn
+:alias: paddle.randn,paddle.tensor.randn,paddle.tensor.random.randn
+
+
+
 该 API 用于生成数据符合标准正态随机分布（均值为 0，方差为 1 的正态随机分布）的 Tensor。
 
 参数：

doc/fluid/api_cn/tensor_cn/randperm_cn.rst

@@ -5,6 +5,11 @@ randperm
 
 .. py:function:: paddle.tensor.random.randperm(n, out=None, dtype="int64", device=None, stop_gradient=True, seed=0)
 
+:alias_main: paddle.randperm
+:alias: paddle.randperm,paddle.tensor.randperm,paddle.tensor.random.randperm
+
+
+
 该OP返回一个数值在0到n-1、顺序随机的整数排列。
 
 参数: 

doc/fluid/api_cn/tensor_cn/roll_cn.rst

@@ -5,6 +5,11 @@ roll
 
 .. py:function:: paddle.roll(input, shifts, dims=None):
 
+:alias_main: paddle.roll
+:alias: paddle.roll,paddle.tensor.roll,paddle.tensor.manipulation.roll
+
+
+
 该OP沿着指定维度对输入 ``input`` 进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入。如果 ``dims`` 为 ``None`` ，则输入在被循环滚动之前，会先展平成 ``1-D Tensor`` ，滚动操作完成后恢复成原来的形状。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/sin_cn.rst

@@ -5,6 +5,12 @@ sin
 
 .. py:function:: paddle.sin(x, name=None, out=None)
 
+:alias_main: paddle.sin
+:alias: paddle.sin,paddle.tensor.sin,paddle.tensor.math.sin
+:update_api: paddle.fluid.layers.sin
+
+
+
 计算输入的正弦值。
 
 .. math::

doc/fluid/api_cn/tensor_cn/sort_cn.rst

@@ -5,6 +5,12 @@ sort
 
 .. py:function:: paddle.sort(input, axis=-1, descending=False, out=None, name=None)
 
+:alias_main: paddle.sort
+:alias: paddle.sort,paddle.tensor.sort,paddle.tensor.search.sort
+:update_api: paddle.fluid.layers.argsort
+
+
+
 对输入变量沿给定轴进行排序，输出排序好的数据和相应的索引，其维度和输入相同。**默认升序排列，如果需要降序排列设置** ``descending=True`` 。
 
 

doc/fluid/api_cn/tensor_cn/split_cn.rst

@@ -4,6 +4,12 @@ split
 
 .. py:function:: paddle.tensor.split(input, num_or_sections, dim=-1, name=None)
 
+:alias_main: paddle.split
+:alias: paddle.split,paddle.tensor.split,paddle.tensor.manipulation.split
+:update_api: paddle.fluid.layers.split
+
+
+
 该OP将输入Tensor分割成多个子Tensor。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/sqrt_cn.rst

@@ -5,6 +5,12 @@ sqrt
 
 .. py:function:: paddle.sqrt(x, name=None, out=None)
 
+:alias_main: paddle.sqrt
+:alias: paddle.sqrt,paddle.tensor.sqrt,paddle.tensor.math.sqrt
+:update_api: paddle.fluid.layers.sqrt
+
+
+
 计算输入的算数平方根。
 
 .. math::

doc/fluid/api_cn/tensor_cn/squeeze_cn.rst

@@ -4,6 +4,12 @@ squeeze
 
 .. py:function:: paddle.tensor.squeeze(input, zxes, name=None)
 
+:alias_main: paddle.squeeze
+:alias: paddle.squeeze,paddle.tensor.squeeze,paddle.tensor.manipulation.squeeze
+:update_api: paddle.fluid.layers.squeeze
+
+
+
 该OP会根据axes压缩输入Tensor的维度。如果指定了axes，则会删除axes中指定的维度，axes指定的维度要等于1。如果没有指定axes，那么所有等于1的维度都会被删除。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/stack_cn.rst

@@ -4,6 +4,12 @@ stack
 
 .. py:function:: paddle.tensor.stack(x, axis=0)
 
+:alias_main: paddle.stack
+:alias: paddle.stack,paddle.tensor.stack,paddle.tensor.manipulation.stack
+:update_api: paddle.fluid.layers.stack
+
+
+
 该OP沿 axis 轴对输入 x 进行堆叠操作。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/std_cn.rst

@@ -3,6 +3,11 @@ std
 
 .. py:function:: paddle.std(input, axis=None, keepdim=False, unbiased=True, out=None, name=None)
 
+:alias_main: paddle.std
+:alias: paddle.std,paddle.tensor.std,paddle.tensor.stat.std
+
+
+
 根据指定的axis计算input的标准差。
 
 参数：

doc/fluid/api_cn/tensor_cn/sum_cn.rst

@@ -5,6 +5,12 @@ sum
 
 .. py:function:: paddle.sum(input, dim=None, dtype=None, keep_dim=False, name=None)
 
+:alias_main: paddle.sum
+:alias: paddle.sum,paddle.tensor.sum,paddle.tensor.math.sum
+:update_api: paddle.fluid.layers.reduce_sum
+
+
+
 该OP是对指定维度上的Tensor元素进行求和运算，并输出相应的计算结果。
 
 参数：

doc/fluid/api_cn/tensor_cn/t_cn.rst

@@ -5,6 +5,11 @@ t
 
 .. py:function:: paddle.tensor.t(input, name=None)
 
+:alias_main: paddle.t
+:alias: paddle.t,paddle.tensor.t,paddle.tensor.linalg.t
+
+
+
 该OP对小于等于2维的Tensor进行数据转置。0维和1维Tensor返回本身，2维Tensor等价于perm设置为0，1的 :ref:`cn_api_fluid_layers_transpose` 函数。
 
 参数：

doc/fluid/api_cn/tensor_cn/tanh_cn.rst

@@ -5,6 +5,12 @@ tanh
 
 .. py:function:: paddle.tanh(x, name=None, out=None)
 
+:alias_main: paddle.tanh
+:alias: paddle.tanh,paddle.tensor.tanh,paddle.tensor.math.tanh
+:update_api: paddle.fluid.layers.tanh
+
+
+
 tanh 激活函数
 
 .. math::

doc/fluid/api_cn/tensor_cn/trace_cn.rst

@@ -5,6 +5,11 @@ trace
 
 .. py:function:: paddle.trace(input, offset=0, dim1=0, dim2=1)
 
+:alias_main: paddle.trace
+:alias: paddle.trace,paddle.tensor.trace,paddle.tensor.math.trace
+
+
+
 该 OP 计算输入 Tensor 在指定平面上的对角线元素之和，并输出相应的计算结果。
 
 如果输入是 2D Tensor，则返回对角线元素之和。 

doc/fluid/api_cn/tensor_cn/tril_cn.rst

@@ -5,6 +5,11 @@ tril
 
 .. py:function:: paddle.tensor.tril(input, diagonal=0, name=None)
 
+:alias_main: paddle.tril
+:alias: paddle.tril,paddle.tensor.tril,paddle.tensor.creation.tril
+
+
+
 返回输入矩阵 `input` 的下三角部分，其余部分被设为0。
 矩形的下三角部分被定义为对角线上和下方的元素。
 

doc/fluid/api_cn/tensor_cn/triu_cn.rst

@@ -5,6 +5,11 @@ triu
 
 .. py:function:: paddle.tensor.triu(input, diagonal=0, name=None)
 
+:alias_main: paddle.triu
+:alias: paddle.triu,paddle.tensor.triu,paddle.tensor.creation.triu
+
+
+
 返回输入矩阵 `input` 的上三角部分，其余部分被设为0。
 矩形的上三角部分被定义为对角线上和上方的元素。
 

doc/fluid/api_cn/tensor_cn/unbind_cn.rst

@@ -4,6 +4,11 @@ unbind
 
 .. py:function:: paddle.tensor.unbind(input, axis=0)
 
+:alias_main: paddle.unbind
+:alias: paddle.unbind,paddle.tensor.unbind,paddle.tensor.manipulation.unbind
+
+
+
 该OP将输入Tensor按照指定的维度分割成多个子Tensor。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/unsqueeze_cn.rst

@@ -4,6 +4,12 @@ unsqueeze
 
 .. py:function:: paddle.tensor.unsqueeze(input, axes, name=None)
 
+:alias_main: paddle.unsqueeze
+:alias: paddle.unsqueeze,paddle.tensor.unsqueeze,paddle.tensor.manipulation.unsqueeze
+:update_api: paddle.fluid.layers.unsqueeze
+
+
+
 该OP向输入（input）的shape中一个或多个位置（axes）插入维度。
 
 **参数**：

doc/fluid/api_cn/tensor_cn/var_cn.rst

@@ -3,6 +3,11 @@ var
 
 .. py:function:: paddle.var(input, axis=None, keepdim=False, unbiased=True, out=None, name=None)
 
+:alias_main: paddle.var
+:alias: paddle.var,paddle.tensor.var,paddle.tensor.stat.var
+
+
+
  沿给定的轴 axis 计算输入变量所有元素的方差。
 
   参数：

doc/fluid/api_cn/tensor_cn/where_cn.rst

@@ -5,6 +5,12 @@ where
 
 .. 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返回一个根据输入 ``condition``, 选择 ``x`` 或 ``y`` 的元素组成的多维 ``Tensor``  ：
 
 .. math::

doc/fluid/api_cn/tensor_cn/zeros_cn.rst

@@ -5,6 +5,12 @@ zeros
 
 .. py:function:: paddle.zeros(shape, dtype, out=None, device=None)
 
+:alias_main: paddle.zeros
+:alias: paddle.zeros,paddle.tensor.zeros,paddle.tensor.creation.zeros
+:update_api: paddle.fluid.layers.zeros
+
+
+
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor。
 
 参数：

doc/fluid/api_cn/tensor_cn/zeros_like_cn.rst

@@ -5,6 +5,12 @@ zeros_like
 
 .. py:function:: paddle.zeros_like(input, dtype=None, device=None, name=None)
 
+:alias_main: paddle.zeros_like
+:alias: paddle.zeros_like,paddle.tensor.zeros_like,paddle.tensor.creation.zeros_like
+:update_api: paddle.fluid.layers.zeros_like
+
+
+
 
 该OP创建一个和input具有相同的形状和数据类型的全零Tensor。
 

doc/fluid/api_cn/transpiler_cn/DistributeTranspilerConfig_cn.rst

@@ -3,10 +3,13 @@
 DistributeTranspilerConfig
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.transpiler.DistributeTranspilerConfig
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 单机任务切换为分布式任务的配置类，用户可根据需求进行配置，如指定同步/异步训练，指定节点个数及模型切分逻辑。
 
 返回：None

doc/fluid/api_cn/transpiler_cn/DistributeTranspiler_cn.rst

@@ -3,10 +3,13 @@
 DistributeTranspiler
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.transpiler.DistributeTranspiler (config=None)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 
 该类可以把fluid program转变为分布式数据并行计算的program, 有PServer和NCCL2两种模式。
 在Pserver（全称：parameter server）模式下， 通过 ``transpile`` 将用于单机训练的 ``program``  转译为可用于parameter server的分布式架构(即PServer,参数服务器)来进行训练的program。

doc/fluid/api_cn/transpiler_cn/HashName_cn.rst

@@ -3,10 +3,13 @@
 HashName
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.transpiler.HashName(pserver_endpoints)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该方法使用 python ``Hash()`` 函数将变量散列到多个parameter server节点。
 
 参数:

doc/fluid/api_cn/transpiler_cn/RoundRobin_cn.rst

@@ -3,10 +3,13 @@
 RoundRobin
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:class:: paddle.fluid.transpiler.RoundRobin(pserver_endpoints)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 该方法使用 ``RoundRobin`` 的方式将变量散列到多个parameter server终端。
 
 `RondRobin <https://en.wikipedia.org/wiki/Round-robin_scheduling>`_

doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst

@@ -3,8 +3,11 @@
 memory_optimize
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True)
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**
\ No newline at end of file

doc/fluid/api_cn/transpiler_cn/release_memory_cn.rst

@@ -3,8 +3,11 @@
 release_memory
 -------------------------------
 
-**注意：该API仅支持【静态图】模式**
 
 .. py:function:: paddle.fluid.transpiler.release_memory(input_program, skip_opt_set=None) 
 
+:api_attr: 声明式编程模式（静态图)
+
+
+
 **从1.6版本开始此接口不再推荐使用，请不要在新写的代码中使用它，1.6+版本已默认开启更优的存储优化策略**
\ No newline at end of file

doc/fluid/api_cn/unique_name_cn/generate_cn.rst

@@ -5,6 +5,9 @@ generate
 
 .. py:function:: paddle.fluid.unique_name.generate(key)
 
+
+
+
 该接口产生以前缀key开头的唯一名称。目前，Paddle通过从0开始的编号对相同前缀key的名称进行区分。例如，使用key=fc连续调用该接口会产生fc_0, fc_1, fc_2等不同名称。
 
 参数:

doc/fluid/api_cn/unique_name_cn/guard_cn.rst

@@ -5,6 +5,9 @@ guard
 
 .. py:function:: paddle.fluid.unique_name.guard(new_generator=None)
 
+
+
+
 该接口用于更改命名空间，与with语句一起使用。使用后，在with语句的上下文中使用新的命名空间，调用generate接口时相同前缀的名称将从0开始重新编号。
 
 参数:

doc/fluid/api_cn/unique_name_cn/switch_cn.rst

@@ -5,6 +5,9 @@ switch
 
 .. py:function:: paddle.fluid.unique_name.switch(new_generator=None)
 
+
+
+
 该接口将当前上下文的命名空间切换到新的命名空间。该接口与guard接口都可用于更改命名空间，推荐使用guard接口，配合with语句管理命名空间上下文。
 
 参数: