Fix problems of chinese docs (#1436)

* Fix problems of chinese docs

* Revise chinese docs

* Add more fixes

* Add data type comments for some inputs

doc/fluid/api_cn/layers_cn/autoincreased_step_counter_cn.rst

@@ -5,16 +5,16 @@ autoincreased_step_counter
 
 .. py:function:: paddle.fluid.layers.autoincreased_step_counter(counter_name=None, begin=1, step=1)
 
-创建一个自增变量，每个mini-batch返回主函数运行次数，变量自动加1，默认初始值为1.
+创建一个自增变量，每个迭代累加一次，默认首次返回值为 1，默认累加步长为 1。
 
 参数：
-    - **counter_name** (str)-计数名称，默认为 ``@STEP_COUNTER@``
-    - **begin** (int)-开始计数
-    - **step** (int)-执行之间增加的步数
+    - **counter_name** (str, 可选) - 该计数器的名称，默认为 ``@STEP_COUNTER@`` 。
+    - **begin** (int) - 该计数器返回的第一个值。
+    - **step** (int) - 累加步长。
 
-返回：全局运行步数
+返回：累加结果，数据类型为 int64
 
-返回类型：变量（Variable）
+返回类型：Variable
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/bilinear_tensor_product_cn.rst

@@ -13,22 +13,24 @@ bilinear_tensor_product
        out_{i} = x * W_{i} * {y^\mathrm{T}}, i=0,1,...,size-1
 
 在这个公式中：
-  - :math:`x`: 第一个输入，包含M个元素，形状为[batch_size, M]
-  - :math:`y`: 第二个输入，包含N个元素，形状为[batch_size, N]
-  - :math:`W_{i}`: 第i个被学习的权重，形状是[M, N]
-  - :math:`out_{i}`: out的第i个元素，形状是[batch_size, size]
-  - :math:`y^\mathrm{T}`: :math:`y_{2}` 的转置
+  - :math:`x`: 第一个输入，包含 :math:`M` 个元素，形状为 [batch_size, M]。
+  - :math:`y`: 第二个输入，包含 :math:`N` 个元素，形状为 [batch_size, N]。
+  - :math:`W_{i}`: 第 :math:`i` 个被学习的权重，形状是 [M, N]。
+  - :math:`out_{i}`: 输出的第 :math:`i` 个元素，形状是 [batch_size, size]。
+  - :math:`y^\mathrm{T}`: :math:`y_{2}` 的转置。
 
 参数：
-    - **x** (Variable): 2-D 输入张量，形状为 [batch_size, M]
-    - **y** (Variable): 2-D 输入张量，形状为 [batch_size, N]
-    - **size** (int): 此层的维度，
-    - **act** (str, default None): 应用到该层输出的激活函数
-    - **name** (str, default None): 该层的名称
-    - **param_attr** (ParamAttr, default None): 可学习参数/权重（w） 的参数属性
-    - **bias_attr** (ParamAttr, default None): 偏差的参数属性，如果设置为False，则不会向输出单元添加偏差。如果设置为零，偏差初始化为零。默认值:None
-
-返回： Variable: 一个形为[batch_size, size]的2-D张量
+    - **x** (Variable): 2-D 输入张量，形状为 [batch_size, M], 数据类型为 float32 或 float64。
+    - **y** (Variable): 2-D 输入张量，形状为 [batch_size, N]，数据类型与 **x** 一致。
+    - **size** (int): 此层的维度。
+    - **act** (str, 可选): 应用到该层输出的激活函数。
+    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为 None。
+    - **param_attr** (ParamAttr，可选) ：指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **bias_attr** (ParamAttr，可选) : 指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+
+返回： 一个形为 [batch_size, size] 的 2-D 张量。
+
+返回类型：Variable
 
 **代码示例：**
 

doc/fluid/api_cn/layers_cn/crf_decoding_cn.rst

@@ -5,23 +5,26 @@ crf_decoding
 
 .. py:function::  paddle.fluid.layers.crf_decoding(input, param_attr, label=None)
 
-该函数读取由 ``linear_chain_crf`` 学习的emission feature weights（发射状态特征的权重）和 transition feature weights(转移特征的权重)。
-本函数实现了Viterbi算法，可以动态地寻找隐藏状态最可能的序列，该序列也被称为Viterbi路径（Viterbi path），从而得出的标注(tags)序列。
 
-这个运算的结果会随着 ``Label`` 参数的有无而改变：
 
-      1. ``Label`` 非None的情况，在实际训练中时常发生。此时本函数会协同 ``chunk_eval`` 工作。本函数会返回一行形为[N X 1]的向量，其中值为0的部分代表该label不适合作为对应结点的标注，值为1的部分则反之。此类型的输出可以直接作为 ``chunk_eval`` 算子的输入
+该层读取由 :ref:`cn_api_fluid_layers_linear_chain_crf` 学习的 emission feature weights（发射状态特征的权重）和 transition feature weights (转移特征的权重) 进行解码。
+本层实现了 Viterbi 算法，可以动态地寻找隐藏状态最可能的序列，该序列也被称为 Viterbi 路径（Viterbi path），从而得到观察标签 (tags) 序列。
 
-      2. 当没有 ``Label`` 时，该函数会执行标准decoding过程
+这个层运算的结果会随着输入 ``Label`` 的有无而改变：
 
-（没有 ``Label`` 时）该运算返回一个形为 [N X 1]的向量，其中元素取值范围为 0 ~ 最大标注个数-1，分别为预测出的标注（tag）所在的索引。
+      1. ``Label`` 非 None 的情况，在实际训练中时常发生。此时本层会协同 :ref:`cn_api_fluid_layers_chunk_eval` 工作。在 LoDTensor 模式下，本层会返回一行形为 [N X 1]  的向量，在 padding 模式下，返回形状则为 [B x S]，其中值为 0 的部分代表该 label 不适合作为对应结点的标注，值为1的部分则反之。此类型的输出可以直接作为 :ref:`cn_api_fluid_layers_chunk_eval` 算子的输入；
+
+      2. 当没有 ``Label`` 时，该函数会执行标准解码过程；
+
+（没有 ``Label`` 时）该运算返回一个形状为 [N X 1] 或 [B x S] 的向量，此处的形状取决于输入是 LoDTensor 还是普通 Tensor，其中元素取值范围为 0 ~ 最大标注个数-1，分别为预测出的标注（tag）所在的索引。
 
 参数：
-    - **input** (Variable)(LoDTensor，默认类型为 LoDTensor<float>) — 一个形为 [N x D] 的LoDTensor，其中 N 是mini-batch的大小，D是标注（tag) 的总数。 该输入是 ``linear_chain_crf`` 的 unscaled emission weight matrix （未标准化的发射权重矩阵）
-    - **param_attr** (ParamAttr) — 参与训练的参数的属性
-    - **label** (Variable)(LoDTensor，默认类型为 LoDTensor<int64_t>) —  形为[N x 1]的正确标注（ground truth）。 该项可选择传入。 有关该参数的更多信息，请详见上述描述
+    - **input** (Variable) — 一个形为 [N x D] 的 LoDTensor，其中 N 是mini-batch的大小，D是标注（tag) 的总数； 或者形为 [B x S x D] 的普通 Tensor，B 是批次大小，S 是序列最大长度，D 是标注的总数。 该输入是 :ref:`cn_api_fluid_layers_linear_chain_crf`` 的 unscaled emission weight matrix （未标准化的发射权重矩阵）。数据类型为 float32 或者 float64。
+    - **param_attr** (ParamAttr，可选) ：指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **label** (Variable，可选) —  形为 [N x 1] 的正确标注（ground truth）（LoDTensor 模式），或者形状为 [B x S]。 有关该参数的更多信息，请详见上述描述。数据类型为 int64。
+    - **length** (Variable，可选) —  形状为 [B x 1], 表示输入序列的真实长度。该输入非 None，表示该层工作在 padding 模式下，即 ``input`` 和 ``label`` 都是带 padding 的普通 Tensor。数据类型为 int64。
 
-返回：(LoDTensor, LoDTensor<int64_t>)decoding结果。具体内容根据 ``Label`` 参数是否提供而定。请参照函数介绍来详细了解。
+返回：解码结果具体内容根据 ``Label`` 参数是否提供而定，请参照上面的介绍来详细了解。
 
 返回类型： Variable
 

doc/fluid/api_cn/layers_cn/gather_cn.rst

@@ -5,14 +5,13 @@ gather
 
 .. py:function:: paddle.fluid.layers.gather(input, index, overwrite=True)
 
-收集层（gather layer）
-
-根据索引index获取X的最外层维度的条目，并将它们串连在一起。
+根据索引 ``index`` 获取输入（input）的最外层维度的条目，并将它们拼接在一起。
 
 .. math::
-                        Out=X[Index]
 
-::
+        Out=X[Index]
+
+.. code-block:: text
 
         X = [[1, 2],
              [3, 4],
@@ -27,13 +26,13 @@ gather
 
 
 参数:
-         - **input** (Variable) - input的秩rank >= 1。
-        - **index** (Variable) - index的秩rank = 1。
-        - **overwrite** (bool) - 具有相同索引时更新grad的模式。如果为True，则使用覆盖模式更新相同索引的grad，如果为False，则使用accumulate模式更新相同索引的grad。Default值为True。
+        - **input** (Variable) - 输入, 秩 ``rank >= 1`` , 支持的数据类型包括 int32、int64、float32、float64 和 uint8 (CPU)、float16（GPU） 。
+        - **index** (Variable) - 索引，秩 ``rank = 1``, 数据类型为 int32 或 int64。
+        - **overwrite** (bool) - 具有相同索引时在反向更新梯度的模式。如果为 ``True`` ，则使用覆盖模式更新相同索引的梯度；如果为 ``False`` ，则使用累积模式更新相同索引的梯度。默认值为 ``True`` 。
 
 返回：和输入的秩相同的输出张量。
 
-返回类型：output (Variable)
+返回类型：Variable
 
 **代码示例**
 

doc/fluid/api_cn/layers_cn/gaussian_random_batch_size_like_cn.rst

@@ -5,21 +5,21 @@ gaussian_random_batch_size_like
 
 .. py:function:: paddle.fluid.layers.gaussian_random_batch_size_like(input, shape, input_dim_idx=0, output_dim_idx=0, mean=0.0, std=1.0, seed=0, dtype='float32')
 
-用于使用高斯随机发生器初始化张量。分布的defalut均值为0.并且分布的defalut标准差（std）为1.用户可以通过输入参数设置mean和std。
+使用高斯随机发生器初始化张量。高斯分布的默认均值（mean）为0，默认标准差（std）为 1 。用户可以通过输入参数设置 mean 和 std 。
 
 参数：
-        - **input** （Variable）- 其input_dim_idx'th维度指定batch_size的张量（Tensor）。
-        - **shape** （元组|列表）- 输出的形状。
-        - **input_dim_idx** （Int）- 默认值0.输入批量大小维度的索引。
-        - **output_dim_idx** （Int）- 默认值0.输出批量大小维度的索引。
-        - **mean** （Float）- （默认值0.0）高斯分布的平均值（或中心值）。
-        - **std** （Float）- （默认值 1.0）高斯分布的标准差（std或spread）。
-        - **seed** （Int）- （默认为0）用于随机数引擎的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此算子将始终每次生成相同的随机数。
-        - **dtype** （np.dtype | core.VarDesc.VarType | str）- 输出数据的类型为float32，float_16，int等。
-
-返回：        指定形状的张量将使用指定值填充。
-
-返回类型：        输出（Variable）。
+        - **input** （Variable）- 其 input_dim_idx'th 维度指定 batch_size 的张量（Tensor）。
+        - **shape** （tuple|list）- 输出的形状。
+        - **input_dim_idx** （Int）- （默认值0）输入批量大小维度的索引。
+        - **output_dim_idx** （Int）- （默认值0）输出批量大小维度的索引。
+        - **mean** （float）- （默认值 0.0）高斯分布的平均值（或中心值）。
+        - **std** （float）- （默认值 1.0）高斯分布的标准差（std或spread）。
+        - **seed** （int）- （默认值为 0）用于随机数发生器的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此算子每次将始终生成相同的随机数。
+        - **dtype** （np.dtype | core.VarDesc.VarType | str）- 输出数据的类型，float32、float_16、int 等。
+
+返回：指定形状的张量，由从高斯分布抽样产生的随机数所填充。
+
+返回类型：Variable
 
 
 

doc/fluid/api_cn/layers_cn/log_loss_cn.rst

@@ -7,7 +7,7 @@ log_loss
 
 **负log loss层**
 
-该层对输入的预测结果和目的标签进行计算，返回负log loss损失值。
+该 OP 对输入的预测结果和目标标签进行计算，返回负对数损失值。
 
 .. math::
 
@@ -15,14 +15,14 @@ log_loss
 
 
 参数:
-  - **input** (Variable|list) – 形为[N x 1]的二维张量, 其中N为batch大小。 该输入是由先前运算得来的概率集。
-  - **label** (Variable|list) – 形为[N x 1]的二维张量，承载着正确标记的数据， 其中N为batch大小。
+  - **input** (Variable) – 形为 [N x 1] 的二维张量, 其中 N 为 batch 大小。该输入是由前驱算子计算得来的概率， 数据类型是 float32。
+  - **label** (Variable) – 形为 [N x 1] 的二维张量，真值标签， 其中 N 为 batch 大小，数据类型是 float32。
   - **epsilon** (float) – epsilon
-  - **name** (string) – log_loss层的名称
+  - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
-返回： 形为[N x 1]的二维张量，承载着负log_loss值
+返回： 形为[N x 1]的二维张量，计算出的负log_loss值，数据类型为 float32
 
-返回类型: 变量（Variable）
+返回类型: Variable
 
 
 **代码示例**

doc/fluid/api_cn/layers_cn/margin_rank_loss_cn.rst

@@ -5,7 +5,7 @@ margin_rank_loss
 
 .. py:function:: paddle.fluid.layers.margin_rank_loss(label, left, right, margin=0.1, name=None)
 
-margin rank loss（差距排序损失）层。在排序问题中，它可以比较传进来的 ``left`` 得分和 ``right`` 得分。
+margin rank loss（间隔排序损失）层。在排序问题中，它可以比较来自排序网络的输入 ``left`` 和输入 ``right`` 的得分。
 
 可用如下等式定义：
 
@@ -14,15 +14,15 @@ margin rank loss（差距排序损失）层。在排序问题中，它可以比
 
 
 参数:
-  - **label** (Variable) – 表明是否左元素排名要高于右元素
-  - **left** (Variable) – 左元素排序得分
-  - **right** (Variable) – 右元素排序得分
-  - **margin** (float) – 指定固定的得分差
-  - **name** (str|None) – 可选项，该层的命名。如果为None, 该层将会被自动命名
+  - **label** (Variable) – 表示输入 ``left`` 的真实排序是否高于输入 ``right`` , 数据类型为 float32。
+  - **left** (Variable) – 输入 ``left`` 的排序得分， 数据类型为 float32 。
+  - **right** (Variable) – 输入 ``right`` 的排序得分， 数据类型为 float32。
+  - **margin** (float) – 指定的间隔。
+  - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
 
 返回： 排序损失
 
-返回类型: 变量（Variable）
+返回类型: Variable
 
 抛出异常:
   - ``ValueError`` - ``label`` , ``left`` , ``right`` 有一者不为Variable类型时，抛出此异常

doc/fluid/api_cn/layers_cn/nce_cn.rst

@@ -5,28 +5,28 @@ nce
 
 .. 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)
 
-计算并返回噪音对比估计（ noise-contrastive estimation training loss）。
-`请参考 See Noise-contrastive estimation: A new estimation principle for unnormalized statistical models
+计算并返回噪音对比估计损失值（ 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>`_
-该operator默认使用均匀分布进行抽样。
+该层默认使用均匀分布进行抽样。
 
 参数:
-    - **input** (Variable) -  输入变量
-    - **label** (Variable) -  标签
-    - **num_total_classes** (int) - 所有样本中的类别的总数
-    - **sample_weight** (Variable|None) - 存储每个样本权重，shape为[batch_size, 1]存储每个样本的权重。每个样本的默认权重为1.0
-    - **param_attr** (ParamAttr|None) - :math:`可学习参数/nce权重` 的参数属性。如果它没有被设置为ParamAttr的一个属性，nce将创建ParamAttr为param_attr。如没有设置param_attr的初始化器，那么参数将用Xavier初始化。默认值:None
-    - **bias_attr** (ParamAttr|bool|None) -  nce偏置的参数属性。如果设置为False，则不会向输出添加偏置（bias）。如果值为None或ParamAttr的一个属性，则bias_attr=ParamAtt。如果没有设置bias_attr的初始化器，偏置将被初始化为零。默认值:None
-    - **num_neg_samples** (int) - 负样例的数量。默认值是10
-    - **name** (str|None) - 该layer的名称(可选)。如果设置为None，该层将被自动命名
-    - **sampler** (str) – 取样器，用于从负类别中进行取样。可以是 ‘uniform’, ‘log_uniform’ 或 ‘custom_dist’。 默认 ‘uniform’
-    - **custom_dist** (float[]) – 一个 float[] 并且它的长度为 ``num_total_classes`` 。  如果取样器类别为‘custom_dist’，则使用此参数。 custom_dist[i] 是第i个类别被取样的概率。默认为 None
-    - **seed** (int) – 取样器使用的seed。默认为0
-    - **is_sparse** (bool) – 标志位，指明是否使用稀疏更新,  :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows
-
-返回： nce loss
-
-返回类型: 变量（Variable）
+    - **input** (Variable) -  输入变量, 2-D 张量，形状为 [batch_size, dim]，数据类型为 float32 或者 float64。
+    - **label** (Variable) -  标签，2-D 张量，形状为 [batch_size, num_true_class]，数据类型为 int64。
+    - **num_total_classes** (int) - 所有样本中的类别的总数。
+    - **sample_weight** (Variable，可选) - 存储每个样本权重，shape 为 [batch_size, 1] 存储每个样本的权重。每个样本的默认权重为1.0。
+    - **param_attr** (ParamAttr，可选) ：指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **bias_attr** (ParamAttr，可选) : 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **num_neg_samples** (int) - 负样例的数量，默认值是10。
+    - **name** (str，可选) - 该layer的名称，具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+    - **sampler** (str，可选) – 采样器，用于从负类别中进行取样。可以是 ``uniform``, ``log_uniform`` 或 ``custom_dist`` ， 默认 ``uniform`` 。
+    - **custom_dist** (nd.array， 可选) – 第0维的长度为 ``num_total_classes`` 。  如果采样器类别为 ``custom_dist`` ，则使用此参数。custom_dist[i] 是第i个类别被取样的概率。默认为 None
+    - **seed** (int，可选) – 采样器使用的seed。默认为0
+    - **is_sparse** (bool，可选) – 标志位，指明是否使用稀疏更新, 为 ``True`` 时 :math:`weight@GRAD` 和 :math:`bias@GRAD` 的类型会变为 SelectedRows。默认为 ``False`` 。
+
+返回： nce loss，数据类型与 **input** 相同
+
+返回类型: Variable
 
 
 **代码示例**

doc/fluid/api_cn/layers_cn/similarity_focus_cn.rst

@@ -7,15 +7,15 @@ similarity_focus
 
 **实现SimilarityFocus(相似度聚焦)运算**
 
-通过以下三种方式，该层生成一个和输入 ``input`` 同形的mask（掩码）：
+通过以下三个步骤，该层生成一个和输入 ``input`` 同形的 similarity focus mask（相似度聚焦掩码）：
 
 1. 根据 ``axis`` 和 ``indexes`` 提取一个三维张量，第一维为batch大小。
    例如，如果 ``axis=1, indexes=[a]`` , 将得到矩阵 T=X[:, a, :, :] 。
    该例中，如果输入X的形为 (BatchSize, A, B, C) ，则输出张量T的形为 (BatchSize, B, C) 。
 2. 对于每一个索引，在输出T中找到最大值。所以同一行、同一列最多只有一个数字，这意味着如果在第i行，第j列中找到最大值，那么在相应行、列中的其他数值都将被忽略。然后再在剩余的数值中找到下一个最大值。显然，将会产生 min（B,C）个数字，并把三维相似聚焦掩码张量相应位置的元素置为1，其余则置为0。对每个索引按元素进行or运算。
-3. 将这个三维相似度聚焦mask调整、适配于输入 ``input`` 的形状
+3. 将这个三维相似度聚焦掩码张量 broadcast 成输入 ``input`` 的形状
 
-请参照 `Similarity Focus Layer <http://www.aclweb.org/anthology/N16-1108>`_ 。
+请参考 `Similarity Focus Layer <http://www.aclweb.org/anthology/N16-1108>`_ 。
 
 ::
 
@@ -70,11 +70,11 @@ similarity_focus
 
 
 参数:
-  - **input** (Variable) – 输入张量(默认类型为float)。应为一个四维张量，形为[BatchSize, A, B, C]
-  - **axis** (int) – 指明要选择的轴。 可能取值为 1, 2 或 3.
-  - **indexes** (list) – 指明选择维度的索引列表
+  - **input** (Variable) – 输入张量，应为一个四维张量，形为[BatchSize, A, B, C]，数据类型为 float32 或者 float64。
+  - **axis** (int) – 指明要选择的轴。 可能取值为 1, 2 或 3。
+  - **indexes** (list) – 指明选择维度的索引列表。
 
-返回：一个和输入张量同形、同类型的张量变量
+返回：一个和输入 Variable 同形状、同数据类型的 Variable
 
 返回类型：Variable
 

doc/fluid/api_cn/nets_cn/glu_cn.rst

@@ -3,20 +3,20 @@
 glu
 -------------------------------
 .. py:function:: paddle.fluid.nets.glu(input, dim=-1)
-T
-he Gated Linear Units(GLU)由切分（split），sigmoid激活函数和按元素相乘组成。沿着给定维将input拆分成两个大小相同的部分，a和b，计算如下：
+
+门控线性单元 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::
+    GLU(a,b) = a \bigotimes \sigma (b)
 
-    GLU(a,b) = a\bigotimes \sigma (b)
 
 参考论文: `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_
 
 参数：
-    - **input** (Variable) - 输入变量，张量或者LoDTensor
-    - **dim** (int) - 拆分的维度。如果 :math:`dim<0`，拆分的维为 :math:`rank(input)+dim`。默认为-1
+    - **input** (Variable) - 输入变量，多维 Tensor 或 LoDTensor, 支持的数据类型为float32、float64 和 float16（GPU）。
+    - **dim** (int) - 拆分的维度。如果 :math:`dim<0` ，拆分的维为 :math:`rank(input) + dim` 。默认为 -1，即最后一维。
 
-返回：变量 —— 变量的大小为输入的一半
+返回: 计算结果，尺寸为输入大小的一半，数据类型与输入的数据类型相同
 
 返回类型：变量（Variable）
 

doc/fluid/api_cn/optimizer_cn/ExponentialMovingAverage_cn.rst

@@ -5,34 +5,32 @@ ExponentialMovingAverage
 
 .. py:class:: paddle.fluid.optimizer.ExponentialMovingAverage(decay=0.999, thres_steps=None, name=None)
 
-用指数衰减计算参数的移动平均值。
-给出参数 :math:`\theta` ，它的指数移动平均值(exponential moving average, EMA)
-为
+用指数衰减计算参数的滑动平均值。给定参数 :math:`\theta` ，它的指数滑动平均值 (exponential moving average, EMA) 为
 
 .. math::
     \begin{align}\begin{aligned}\text{EMA}_0 & = 0\\\text{EMA}_t & = \text{decay} * \text{EMA}_{t-1} + (1 - \text{decay}) * \theta_t\end{aligned}\end{align}
 
 
-用 ``update()`` 方法计算出的平均结果将保存在由对象创建和维护的临时变量中，并且可以通过调用 ``apply()`` 方法把结果应用于当前模型的参数。另外，``restore()`` 方法用于恢复参数。
+用 ``update()`` 方法计算出的平均结果将保存在由实例化对象创建和维护的临时变量中，并且可以通过调用 ``apply()`` 方法把结果应用于当前模型的参数。同时，可用 ``restore()`` 方法恢复原始参数。
 
-**偏差教正。**  所有的EMAs均初始化为 :math:`0` ，因此它们将为零偏差，可以通过除以因子 :math:`(1 - \text{decay}^t)` 来校正，即在调用 ``apply()`` 方法时应用于参数的真实EMAs将为：
+**偏置校正**  所有的滑动平均均初始化为 :math:`0` ，因此它们相对于零是有偏的，可以通过除以因子 :math:`(1 - \text{decay}^t)` 来校正，因此在调用 ``apply()`` 方法时，作用于参数的真实滑动平均值将为：
 
 .. math::
     \widehat{\text{EMA}}_t = \frac{\text{EMA}_t}{1 - \text{decay}^t}
 
-**衰减率调度。**  一个非常接近于1的很大的衰减率将会导致平均值移动得很慢。更优的策略是，一开始就设置一个相对较小的衰减率。参数thres_steps允许用户传递一个变量以设置衰减率，在这种情况下，
+**衰减率调节**  一个非常接近于1的很大的衰减率将会导致平均值滑动得很慢。更优的策略是，开始时设置一个相对较小的衰减率。参数 ``thres_steps`` 允许用户传递一个变量以设置衰减率，在这种情况下，
 真实的衰减率变为 ：
 
 .. math:: 
     \min(\text{decay}, \frac{1 + \text{thres_steps}}{10 + \text{thres_steps}})
 
-通常thres_steps可以是全局训练steps。
+通常 ``thres_steps`` 可以是全局的训练迭代步数。
      
 
 参数：
     - **decay** (float) – 指数衰减率，通常接近1，如0.999，0.9999，……
-    - **thres_steps** (Variable|None) – 如果不为None，指定衰减率。
-    - **name** (str|None) – 名字前缀（可选项）。
+    - **thres_steps** (Variable, 可选) – 调节衰减率的阈值步数，默认值为 None。
+    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
 
 **代码示例**
 
@@ -85,18 +83,22 @@ ExponentialMovingAverage
 
 .. py:method:: update()
 
-更新指数滑动平均。仅在训练程序中调用此方法。
+更新指数滑动平均，在训练过程中需调用此方法。
 
 .. py:method:: apply(executor, need_restore=True)
 
+模型评测时，将滑动平均的结果作用在参数上。
+
 参数：
-    - **executor** (Executor) – 执行应用的执行引擎。
-    - **need_restore** (bool) –是否在应用后恢复参数。
+    - **executor** (Executor) – 将滑动平均值作用在参数上的执行器。
+    - **need_restore** (bool) –是否在结束后恢复原始参数，默认值为 ``True`` 。
 
 .. py:method:: restore(executor)
 
+恢复参数。
+
 参数：
-    - **executor** (Executor) – 执行存储的执行引擎。
+    - **executor** (Executor) – 执行恢复动作的执行器。
 
 
 

doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst

@@ -6,25 +6,32 @@ 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, regularization=None, exclude_from_weight_decay_fn=None, name=None)
 
 LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
-LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for
+LAMB的优化器旨在不降低精度的前提下增大训练的批量大小，其支持自适应的逐元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for
 Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf>`_ 。
 参数更新如下：
 
 .. math::
 
-    \begin{align}\begin{aligned}m_t &= \beta_1 m_{t - 1}+ (1 - \beta_1)g_t \\\v_t &= \beta_2 v_{t - 1}  + (1 - \beta_2)g_t^2 \\\r_t &= \frac{m_t}{\sqrt{v_t}+\epsilon} \\\w_t &= w_{t-1} -\eta_t \frac{\left \| w_{t-1}\right \|}{\left \| r_t + \lambda w_{t-1}\right \|} (r_t + \lambda w_{t-1})\end{aligned}\end{align}
+    \begin{align}
+    \begin{aligned}
+     m_t &= \beta_1 m_{t - 1}+ (1 - \beta_1)g_t \\
+     v_t &= \beta_2 v_{t - 1}  + (1 - \beta_2)g_t^2 \\
+     r_t &= \frac{m_t}{\sqrt{v_t}+\epsilon} \\
+     w_t &= w_{t-1} -\eta_t \frac{\left \| w_{t-1}\right \|}{\left \| r_t + \lambda w_{t-1}\right \|} (r_t + \lambda w_{t-1})
+    \end{aligned}
+    \end{align}
 
-其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。
+其中 :math:`m` 为第一个动量，:math:`v` 为第二个动量，:math:`\eta` 为学习率，:math:`\lambda` 为 LAMB 权重衰减率。
 
 参数：
-    - **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
+    - **learning_rate** (float|Variable) – 用于更新参数的学习率。可以是浮点数，或数据类型为浮点数的 Variable。
     - **lamb_weight_decay** (float) – LAMB权重衰减率。
-    - **beta1** (float) – 第一个时刻估计的指数衰减率。
-    - **beta2** (float) – 第二个时刻估计的指数衰减率。
+    - **beta1** (float) – 第一个动量估计的指数衰减率。
+    - **beta2** (float) – 第二个动量估计的指数衰减率。
     - **epsilon** (float) – 一个小的浮点值，目的是维持数值稳定性。
     - **regularization** (Regularizer) – 一个正则化器，如fluid.regularizer.L1DecayRegularizer。
-    - **exclude_from_weight_decay_fn** (function) – 当返回值为True时从权重衰减中去除某个参数。 
-    - **name** (str|None) – 名字前缀（可选项）。
+    - **exclude_from_weight_decay_fn** (function) – 当某个参数作为输入该函数返回值为 ``True`` 时，为该参数跳过权重衰减。 
+    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
 
 **代码示例**
 
@@ -44,155 +51,50 @@ Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf
     optimizer.minimize(cost)
 
 
-.. py:method:: apply_gradients(params_grads)
-
-为给定的params_grads对附加优化算子，为minimize过程的第二步
-
-参数：
-    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
-
-返回：  附加在当前Program的算子组成的列表
-
-返回类型：  list
-
-**代码示例**
-
-.. code-block:: python
-
-    import paddle.fluid as fluid
-    loss = network()
-    optimizer = fluid.optimizer.SGD(learning_rate=0.1)
-    params_grads = optimizer.backward(loss)
-    # you may append operations for params_grads here
-    # ...
-    optimizer.apply_gradients(params_grads)
-
-
-.. py:method:: apply_optimize(loss, startup_program, params_grads)
-
-为给定的params_grads对附加优化算子，为minimize过程的第二步。
-
-参数：
-    - **loss** (Variable) – 用于优化过程的损失值变量
-    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
-    - **params_grads** (list)- 用于优化的(param, grad)对组成的列表
-
-返回：  附加在当前Program的算子组成的列表
-
-返回类型：  list
-
-.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
+.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
 
-自动做diff来向当前program附加反向算子，为minimize过程的第一步。
+为网络添加反向计算过程，并根据反向计算所得的梯度，更新parameter_list中的Parameters，最小化网络损失值loss。
 
 参数：
-    - **loss** (Variable) – 用于优化过程的损失值变量
-    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
-    - **parameter_list** (list) – 待更新的Variables组成的列表
-    - **no_grad_set** (set|None) – 应该被无视的Variables集合
-    - **callbacks** (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表
-
-返回：  附加在当前Program的算子组成的列表
-
-返回类型：  list
-
-**代码示例**
-
-详见apply_gradients的示例
+    - **loss** (Variable) – 需要最小化的损失值变量。
+    - **startup_program** (Program, 可选) – 用于初始化parameter_list中参数的 :ref:`cn_api_fluid_Program` , 默认值为None，此时将使用 :ref:`cn_api_fluid_default_startup_program` 
+    - **parameter_list** (list, 可选) – 待更新的Parameter组成的列表， 默认值为None，此时将更新所有的Parameter
+    - **no_grad_set** (set, 可选) – 不需要更新的Parameter的集合，默认值为None
+    - **grad_clip** (GradClipBase, 可选) – 梯度裁剪的策略，静态图模式不需要使用本参数，当前本参数只支持在dygraph模式下的梯度裁剪，未来本参数可能会调整，默认值为None
 
+返回： (optimize_ops, params_grads)，数据类型为(list, list)，其中optimize_ops是 ``minimize()`` 接口为网络添加的OP列表，params_grads是一个由(param, grad)变量对组成的列表，param是Parameter，grad是该Parameter对应的梯度值
 
-.. py:method:: load(stat_dict)
+返回类型： tuple
 
-在dygraph模式下，附带学习率衰减来加载优化器。
-
-参数：
-    - **stat_dict** – load_persistable方法加载的dict
-
-**代码示例**
+**代码示例**：
 
 .. code-block:: python
 
-    from __future__ import print_function
-    import numpy as np
-    import paddle
+    import numpy
     import paddle.fluid as fluid
-    from paddle.fluid.optimizer import SGDOptimizer
-    from paddle.fluid.dygraph.nn import FC
-    from paddle.fluid.dygraph.base import to_variable
-
-    class MLP(fluid.Layer):
-        def __init__(self, name_scope):
-            super(MLP, self).__init__(name_scope)
-
-            self._fc1 = FC(self.full_name(), 10)
-            self._fc2 = FC(self.full_name(), 10)
-
-        def forward(self, inputs):
-            y = self._fc1(inputs)
-            y = self._fc2(y)
-            return y
-
-    with fluid.dygraph.guard():
-        mlp = MLP('mlp')
-        optimizer2 = SGDOptimizer(
-            learning_rate=fluid.layers.natural_exp_decay(
-            learning_rate=0.1,
-            decay_steps=10000,
-            decay_rate=0.5,
-            staircase=True))
-
-        train_reader = paddle.batch(
-                paddle.dataset.mnist.train(), batch_size=128, drop_last=True)
-
-        for batch_id, data in enumerate(train_reader()):
-            dy_x_data = np.array(
-                    [x[0].reshape(1, 28, 28) for x in data]).astype('float32')
-
-            y_data = np.array([x[1] for x in data]).astype('int64').reshape(
-                    128, 1)
-
-            img = to_variable(dy_x_data)
-            label = to_variable(y_data)
-            label._stop_gradient = True
-            cost = mlp(img)
-            avg_loss = fluid.layers.reduce_mean(cost)
-            avg_loss.backward()
-            optimizer.minimize(avg_loss)
-            mlp.clear_gradients()
-            fluid.dygraph.save_persistables(
-                    mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
-            if batch_id == 2:
-                    break
-
-    with fluid.dygraph.guard():
-        mlp_load = MLP('mlp')
-        optimizer_load2 = SGDOptimizer(
-                learning_rate=fluid.layers.natural_exp_decay(
-                learning_rate=0.1,
-                decay_steps=10000,
-                decay_rate=0.5,
-                staircase=True))
-        parameters, optimizers = fluid.dygraph.load_persistables(
-            "save_dir_2")
-        mlp_load.load_dict(parameters)
-        optimizer_load2.load(optimizers)
-    self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
+     
+    x = fluid.layers.data(name='X', shape=[13], dtype='float32')
+    y = fluid.layers.data(name='Y', shape=[1], dtype='float32')
+    y_predict = fluid.layers.fc(input=x, size=1, act=None)
+    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+    loss = fluid.layers.mean(cost)
+    adam = fluid.optimizer.LambOptimizer(learning_rate=0.2)
+    adam.minimize(loss)
+
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+     
+    x = numpy.random.random(size=(10, 13)).astype('float32')
+    y = numpy.random.random(size=(10, 1)).astype('float32')
+    exe.run(fluid.default_startup_program())
+    outs = exe.run(program=fluid.default_main_program(),
+                   feed={'X': x, 'Y': y},
+                   fetch_list=[loss.name])
 
 
-.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
 
 
-通过更新parameter_list来添加操作，进而使损失最小化。
 
-该算子相当于backward()和apply_gradients()功能的合体。
 
-参数：
-    - **loss** (Variable) – 用于优化过程的损失值变量
-    - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
-    - **parameter_list** (list) – 待更新的Variables组成的列表
-    - **no_grad_set** (set|None) – 应该被无视的Variables集合
-    - **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
 
-返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
 
-返回类型：   tuple