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型数组来初始化参数变量。
 
 参数：