refine cn doc

doc/fluid/api_cn/layers_cn/detection_map_cn.rst

@@ -5,39 +5,41 @@ detection_map
 
 .. py:function:: paddle.fluid.layers.detection_map(detect_res, label, class_num, background_label=0, overlap_threshold=0.3, evaluate_difficult=True, has_state=None, input_states=None, out_states=None, ap_version='integral')
 
-检测mAP评估算子。一般步骤如下：首先，根据检测输入和标签计算TP（true positive）和FP（false positive），然后计算mAP评估值。支持'11 point'和积分mAP算法。请从以下文章中获取更多信息：
+该OP用于检测算法的mAP评估。一般步骤如下：首先，根据检测输入和标签计算TP（true positive）和FP（false positive），然后计算mAP评估值。支持'11 point'和积分mAP算法。请从以下文章中获取更多信息：
 
         https://sanchom.wordpress.com/tag/average-precision/
 
         https://arxiv.org/abs/1512.02325
 
 参数：
-        - **detect_res** （LoDTensor）- 用具有形状[M，6]的2-D LoDTensor来表示检测。每行有6个值：[label，confidence，xmin，ymin，xmax，ymax]，M是此小批量中检测结果的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N+1，如果LoD[i+1]-LoD[i]== 0，则表示没有检测到数据。
-        - **label** （LoDTensor）- 2-D LoDTensor用来带有标签的真实数据。每行有6个值：[label，xmin，ymin，xmax，ymax，is_difficult]或5个值：[label，xmin，ymin，xmax，ymax]，其中N是此小批量中真实数据的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N + 1，如果LoD [i + 1] - LoD [i] == 0，则表示没有真实数据。
-        - **class_num** （int）- 类的数目。
-        - **background_label** （int，defalut：0）- background标签的索引，background标签将被忽略。如果设置为-1，则将考虑所有类别。
-        - **overlap_threshold** （float）- 检测输出和真实数据下限的重叠阈值。
-        - **evaluate_difficult** （bool，默认为true）- 通过切换来控制是否对difficult-data进行评估。
-        - **has_state** （Tensor <int>）- 是shape[1]的张量，0表示忽略输入状态，包括PosCount，TruePos，FalsePos。
-        - **input_states** - 如果不是None，它包含3个元素：
+        - **detect_res** （Variable) - 用具有形状[M，6]的2-D LoDTensor来表示检测结果。每行有6个值：[label，confidence，xmin，ymin，xmax，ymax]，M是此mini-batch中检测结果的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N+1，如果LoD[i+1]-LoD[i]== 0，则表示没有检测到数据。数据类型为float32或float64。
+        - **label** （Variable）- 2-D LoDTensor用来带有标签的真实数据。每行有6个值：[label，xmin，ymin，xmax，ymax，is_difficult]或5个值：[label，xmin，ymin，xmax，ymax]，其中N是此mini-batc中真实数据的总数。对于每个实例，第一维中的偏移称为LoD，偏移量为N + 1，如果LoD [i + 1] - LoD [i] == 0，则表示没有真实数据。数据类型为float32或float64。
+        - **class_num** （int）- 检测类别的数目。
+        - **background_label** （int）- background标签的索引，background标签将被忽略。如果设置为-1，则将考虑所有类别，默认为0。
+        - **overlap_threshold** （float）- 检测输出和真实数据下限的重叠阈值，默认为0.3。
+        - **evaluate_difficult** （bool) - 控制是否对难样本进行评估， 默认为True。
+        - **has_state** （Variable）- 是shape[1]的Tensor，0表示忽略输入状态，包括PosCount，TruePos，FalsePos，数据类型为int32或int64。
+        - **input_states** (tuple, 可选) - 表示输入状态，默认为None。如果不是None，它包含3个元素：
 
-            1、pos_count（Tensor）是一个shape为[Ncls，1]的张量，存储每类的输入正例的数量，Ncls是输入分类的数量。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。当输入（PosCount）为空时，不执行累积计算，仅计算当前小批量的结果。
+            1、pos_count（Variable）是一个shape为[Ncls，1]的Tensor，存储每类的输入正例的数量，Ncls是输入分类的数量。此输入用于在执行多个mini-batch累积计算时传递最初mini-batch生成的AccumPosCount。当输入（PosCount）为空时，不执行累积计算，仅计算当前mini-batch的结果。数据类型为int32或int64。
 
-            2、true_pos（LoDTensor）是一个shape为[Ntp，2]的2-D LoDTensor，存储每个类输入的正实例。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。
+            2、true_pos（Variable）是一个shape为[Ntp，2]的2-D LoDTensor，存储每个类输入的正实例。此输入用于在执行多个mini-batch累积计算时传递最初mini-batch生成的AccumPosCount。数据类型为int32或int64。
 
-            3、false_pos（LoDTensor）是一个shape为[Nfp，2]的2-D LoDTensor，存储每个类输入的负实例。此输入用于在执行多个小批量累积计算时传递最初小批量生成的AccumPosCount。
+            3、false_pos（Variable）是一个shape为[Nfp，2]的2-D LoDTensor，存储每个类输入的负实例。此输入用于在执行多个mini-batch累积计算时传递最初mini-batch生成的AccumPosCount。数据类型为int32或int64。
 
-        - **out_states** - 如果不是None，它包含3个元素：
+        - **out_states** (tuple, 可选) - 表示输出状态，默认为None。如果不是None，它包含3个元素：
 
-            1、accum_pos_count（Tensor）是一个shape为[Ncls，1]的Tensor，存储每个类的实例数。它结合了输入（PosCount）和从输入中的（Detection）和（label）计算的正例数。
+            1、accum_pos_count（Variable）是一个shape为[Ncls，1]的Tensor，存储每个类的实例数。它结合了输入（PosCount）和从输入中的（Detection）和（label）计算的正例数。数据类型为int32或int64。
 
-            2、accum_true_pos（LoDTensor）是一个shape为[Ntp'，2]的LoDTensor，存储每个类的正实例。它结合了输入（TruePos）和从输入中（Detection）和（label）计算的正实例数。 。
+            2、accum_true_pos（Variable）是一个shape为[Ntp，2]的LoDTensor，存储每个类的正实例。它结合了输入（TruePos）和从输入中（Detection）和（label）计算的正实例数。数据类型为int32或int64。
 
-            3、accum_false_pos（LoDTensor）是一个shape为[Nfp'，2]的LoDTensor，存储每个类的负实例。它结合了输入（FalsePos）和从输入中（Detection）和（label）计算的负实例数。
+            3、accum_false_pos（Variable）是一个shape为[Nfp，2]的LoDTensor，存储每个类的负实例。它结合了输入（FalsePos）和从输入中（Detection）和（label）计算的负实例数。数据类型为int32或int64。
 
-        - **ap_version** （string，默认'integral'）- AP算法类型，'integral'或'11 point'。
+        - **ap_version** （str）- AP算法类型，有'integral'和'11 point'两种模式，默认为'integral'。
 
-返回：        具有形状[1]的（Tensor），存储mAP的检测评估结果。
+返回：Variable(具有形状[1]的Tensor），存储mAP的检测评估结果。评估结果的数据类型为float32或float64。
+
+返回类型：变量(Variable)
 
 **代码示例**
 

doc/fluid/api_cn/layers_cn/sequence_slice_cn.rst

@@ -7,37 +7,41 @@ sequence_slice
 
 **实现Sequence Slice(序列切片)运算**
 
+**该OP输入只能是LoDTensor, 如果您需要处理的是Tensor类型，请使用 :ref:`cn_api_fluid_layers_slice` 。**
 该层从给定序列中截取子序列。截取依据为所给的开始 ``offset`` （偏移量） 和子序列长 ``length`` 。
 
-仅支持序列数据，LoD level（LoD层次为1）
 ::
     输入变量：
+        (1) input (LoDTensor):
+                input.data = [[a1, a2], [b1, b2], [c1, c2], [d1, d2], [e1, e2]],
+                input.lod = [[3, 2]],
+                input.dims = (5, 2),
 
-        input.data = [[a1, a2], [b1, b2], [c1, c2], [d1, d2], [e1, e2]],
-        input.lod = [[3, 2]],
-        input.dims = (5, 2),
+        (2) offset (Variable):
+                offset.data = [[0], [1]]
+        (3) length (Variable):
+                length.data = [[2], [1]]
+        (4) name (str|None)
 
-    以及 offset.data = [[0], [1]] and length.data = [[2], [1]],
-
-    则输出变量为：
+    输出变量为LoDTensor：
 
         out.data = [[a1, a2], [b1, b2], [e1, e2]],
         out.lod = [[2, 1]],
         out.dims = (3, 2).
 
-.. note::
+.. 注意::
    ``input`` ， ``offset`` ， ``length`` 的第一维大小应相同。
    ``offset`` 从0开始。
 
 参数:
-  - **input** (Variable) – 输入变量 ，承载着完整的序列
-  - **offset** (Variable) – 对每个序列切片的起始索引
-  - **length** (Variable) – 每个子序列的长度
-  - **name** (str|None) – 该层的命名，可选项。 如果None, 则自动命名该层
+  - **input** (Variable) – 输入变量，类型为LoDTensor，承载着完整的序列
+  - **offset** (Variable) – 指定每个序列切片的起始索引，数据类型为int32或int64。
+  - **length** (Variable) – 指定每个子序列的长度，数据类型为int32或int64。
+  - **name**  (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
-返回：输出目标子序列
+返回：Variable(LoDTensor) 序列切片运算结果
 
-返回类型：Variable
+返回类型：变量(Variable), 数据类型与 ``input`` 一致
 
 **代码示例**
 

doc/fluid/api_cn/layers_cn/sigmoid_cross_entropy_with_logits_cn.rst

@@ -5,9 +5,9 @@ sigmoid_cross_entropy_with_logits
 
 .. py:function:: paddle.fluid.layers.sigmoid_cross_entropy_with_logits(x, label, ignore_index=-100, name=None, normalize=False)
 
-在类别不相互独立的分类任务中，该函数可以衡量按元素的可能性误差。可以这么认为，为单一数据点预测标签，它们之间不是完全互斥的关系。例如，一篇新闻文章可以同时关于政治，科技，体育或者同时不包含这些内容。
+在每个类别独立的分类任务中，该OP可以计算按元素的概率误差。可以将其视为预测数据点的标签，其中标签不是互斥的。例如，一篇新闻文章可以同时关于政治，科技，体育或者同时不包含这些内容。
 
-逻辑loss可通过下式计算：
+logistic loss可通过下式计算：
 
 .. math::
     loss = -Labels * log(sigma(X)) - (1 - Labels) * log(1 - sigma(X))
@@ -17,7 +17,7 @@ sigmoid_cross_entropy_with_logits
 .. math::
     sigma(X) = \frac{1}{1 + exp(-X)}
 
-代入最开始的式子，
+代入上方计算logistic loss公式中:
 
 .. math::
     loss = X - X * Labels + log(1 + exp(-X))
@@ -32,15 +32,15 @@ sigmoid_cross_entropy_with_logits
 
 
 参数:
-  - **x** (Variable) - (Tensor, 默认 Tensor<float>)，形为 N x D 的二维张量，N为batch大小，D为类别数目。该输入是一个由先前运算得出的logit组成的张量。logit是未标准化(unscaled)的log概率， 公式为 :math:`log(\frac{p}{1-p})`
-  - **label** (Variable) -  (Tensor, 默认 Tensor<float>) 具有和X相同类型，相同形状的二维张量。该输入张量代表了每个logit的可能标签
-  - **ignore_index** （int） - （int，默认kIgnoreIndex）指定被忽略的目标值，它不会影响输入梯度
-  - **name** (basestring|None) - 输出的名称
-  - **normalize** （bool） - 如果为true，则将输出除以除去ignore_index对应目标外的目标数
+  - **x** (Variable) - (Tensor, 默认 Tensor<float>)，形为 N x D 的二维张量，N为batch大小，D为类别数目。该输入是一个由先前运算得出的logit组成的张量。logit是未标准化(unscaled)的log概率， 公式为 :math:`log(\frac{p}{1-p})`, 数据类型为float32或float64。
+  - **label** (Variable) -  (Tensor, 默认 Tensor<float>) 具有和 ``X`` 相同数据类型，相同形状的二维张量。该输入张量代表了每个logit的可能标签。
+  - **ignore_index** （int） - （int，默认kIgnoreIndex）指定被忽略的目标值，它不会影响输入梯度。
+  - **name**  (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+  - **normalize** （bool） - 如果为true，则将输出除以除去ignore_index对应目标外的目标数，默认为False。
 
-返回： (Tensor, 默认Tensor<float>), 形为 N x D 的二维张量，其值代表了按元素的逻辑loss
+返回： Variable(Tensor, 默认Tensor<float>), 形为 N x D 的二维张量，其值代表了按元素的logistic loss，数据类型为float32或float64。
 
-返回类型：Variable
+返回类型：变量(Variable)
 
 
 

doc/fluid/api_cn/layers_cn/ssd_loss_cn.rst

@@ -5,9 +5,9 @@ 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)
 
-用于SSD的对象检测算法的多窗口损失层
+该OP用于SSD物体检测算法的多窗口损失层
 
-该层用于计算SSD的损失，给定位置偏移预测，置信度预测，候选框和真实框标签，以及实例挖掘的类型。通过执行以下步骤，返回的损失是本地化损失（或回归损失）和置信度损失（或分类损失）的加权和：
+该层用于计算SSD的损失，给定位置偏移预测，置信度预测，候选框和真实框标签，以及难样本挖掘的类型。通过执行以下步骤，返回的损失是本地化损失（或回归损失）和置信度损失（或分类损失）的加权和：
 
 1、通过二分匹配算法查找匹配的边界框。
 
@@ -21,45 +21,45 @@ ssd_loss
 
         2.2、计算置信度损失。
 
-3、应用实例挖掘来获取负示例索引并更新匹配的索引。
+3、应用难样本挖掘算法来获取负样本索引并更新匹配的索引。
 
 4、分配分类和回归目标
 
-        4.1、根据前面的框编码bbox。
+        4.1、根据生成的候选框bbox进行编码。
 
         4.2、分配回归目标。
 
         4.3、分配分类目标。
 
-5、计算总体客观损失。
+5、计算总体的物体损失。
 
-        5.1计算置信度损失。
+        5.1计算置信度(confidence)损失。
 
-        5.1计算本地化损失。
+        5.1计算回归(location)损失。
 
         5.3计算总体加权损失。
 
 参数：
-        - **location** （Variable）- 位置预测是具有形状[N，Np，4]的3D张量，N是批量大小，Np是每个实例的预测总数。 4是坐标值的数量，布局是[xmin，ymin，xmax，ymax]。
-        - **confidence**  (Variable) - 置信度预测是具有形状[N，Np，C]，N和Np的3D张量，它们与位置相同，C是类号。
-        - **gt_box** （Variable）- 真实框（bbox）是具有形状[Ng，4]的2D LoDTensor，Ng是小批量输入的真实框（bbox）的总数。
-        - **gt_label** （Variable）- ground-truth标签是具有形状[Ng，1]的2D LoDTensor。
-        - **prior_box** （Variable）- 候选框是具有形状[Np，4]的2D张量。
-        - **prior_box_var** （Variable）- 候选框的方差是具有形状[Np，4]的2D张量。
+        - **location** （Variable）- 位置预测，具有形状[N，Np，4]的3D-Tensor，N是batch大小，Np是每个实例的预测总数。 4是坐标的维数，布局是[xmin，ymin，xmax，ymax]，xmin，ymin代表box左上坐标，xmax，ymax代表box右下坐标，数据类型为float32或float64。
+        - **confidence**  (Variable) - 置信度(分类)预测，具有形状[N，Np，C]的3D-Tensor，N是batch大小，Np是每个实例的预测总数，C是类别数量，数据类型为float32或float64。
+        - **gt_box** （Variable）- 真实框(bbox),具有形状[Ng，4]的2D LoDTensor，Ng是mini-batch输入的真实框（bbox）的总数,4是坐标的维数，布局是[xmin，ymin，xmax，ymax]，xmin，ymin代表box左上坐标，xmax，ymax代表box右下坐标，数据类型为float32或float64。
+        - **gt_label** （Variable）- ground-truth标签, 具有形状[Ng，1]的2D LoDTensor,Ng是mini-batch输入的真实框（bbox）的总数,1表示类别号，数据类型为float32或float64。
+        - **prior_box** （Variable）- 检测网络生成的候选框, 具有形状[Np，4]的2D-Tensor，Np是生成的候选框总数，4是坐标的维数，布局是[xmin，ymin，xmax，ymax]，xmin，ymin代表box左上坐标，xmax，ymax代表box右下坐标，数据类型为float32或float64。。
+        - **prior_box_var** （Variable）- 候选框的方差, 具有形状[Np，4]的2D张量，形状及数据类型同 ``prior_box`` 。
         - **background_label** （int）- background标签的索引，默认为0。
-        - **overlap_threshold** （float）- 当找到匹配的框，如果 ``match_type`` 为'per_prediction'，请使用 ``overlap_threshold`` 确定额外匹配的bbox。默认为0.5。
-        - **neg_pos_ratio** （float）- 负框与正框的比率，仅在 ``mining_type`` 为'max_negative'时使用，3.0由defalut使用。
-        - **neg_overlap** （float）- 不匹配预测的负重叠上限。仅当mining_type为'max_negative'时使用，默认为0.5。
-        - **loc_loss_weight** （float）- 本地化丢失的权重，默认为1.0。
+        - **overlap_threshold** （float）- 额外匹配的bbox阈值，当找到匹配的框，如果 ``match_type`` 为'per_prediction'，使用 ``overlap_threshold`` 确定额外匹配的bbox。默认为0.5。
+        - **neg_pos_ratio** （float）- 负框与正框的比率，仅在 ``mining_type`` 为'max_negative'时使用，默认为3.0。
+        - **neg_overlap** （float）- 不匹配预测的负重叠上限。仅当 ``mining_type`` 为'max_negative'时使用，默认为0.5。
+        - **loc_loss_weight** （float）- 回归损失的权重，默认为1.0。
         - **conf_loss_weight** （float）- 置信度损失的权重，默认为1.0。
-        - **match_type** （str）- 训练期间匹配方法的类型应为'bipartite'或'per_prediction'，'per_prediction'由defalut提供。
-        - **mining_type** （str）- 硬示例挖掘类型应该是'hard_example'或'max_negative'，现在只支持max_negative。
-        - **normalize** （bool）- 是否通过输出位置的总数将SSD丢失标准化，默认为True。
-        - **sample_size** （int）- 负框的最大样本大小，仅在 ``mining_type`` 为'hard_example'时使用。
+        - **match_type** （str）- 训练期间匹配方法的类型应为'bipartite'或'per_prediction'，默认为'per_prediction'。
+        - **mining_type** （str）- 难样本挖掘类型，分为'hard_example'或'max_negative'，目前只支持'max_negative'。
+        - **normalize** （bool）- 是否通过输出位置的总数将SSD损失标准化，默认为True。
+        - **sample_size** （int）- 负样本框的最大样本大小，仅在 ``mining_type`` 为'hard_example'时使用。
 
-返回：        具有形状[N * Np，1]，N和Np的定位损失和置信度损失的加权和与它们在位置上的相同。
+返回：  Variable(Tensor)  定位损失和置信度损失的加权和, 具有形状[N * Np，1], N是batch大小，Np是每个实例的预测总数，数据类型为float32或float64。
 
-抛出异常：        ``ValueError`` - 如果 ``mining_type`` 是'hard_example'，现在只支持 ``max_negative`` 的挖掘类型。
+抛出异常：        ``ValueError`` - 如果 ``mining_type`` 是'hard_example'，目前只支持 ``max_negative`` 的挖掘类型。
 
 **代码示例**