refine cn doc (#1314)

9bb7c9cd · Guanghua Yu · whs · 70df6fff · 9bb7c9cd · 9bb7c9cd
5 changed file
--- a/doc/fluid/api_cn/layers_cn/detection_map_cn.rst
+++ b/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)

 **代码示例**


--- a/doc/fluid/api_cn/layers_cn/sequence_slice_cn.rst
+++ b/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`` 一致

 **代码示例**


--- a/doc/fluid/api_cn/layers_cn/sigmoid_cross_entropy_with_logits_cn.rst
+++ b/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)




--- a/doc/fluid/api_cn/layers_cn/ssd_loss_cn.rst
+++ b/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`` 的挖掘类型。

 **代码示例**


--- a/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst
+++ b/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst
@@ -5,27 +5,32 @@ 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')

-计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 5
+该OP用于计算检测网络的平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。

 通常步骤如下：

-1. 根据detectors中的输入和label，计算  true positive 和 false positive
-2. 计算map，支持 ‘11 point’ and ‘integral’
+1. 根据检测器中的输入和label，计算True Positive(TP)真正例 和 False Positive(FP)假正例
+2. 计算map，支持 ``11 point`` 和 ``integral`` 模式

 请从以下文章中获取更多信息：
    - https://sanchom.wordpress.com/tag/average-precision/
    - https://arxiv.org/abs/1512.0232

 参数：
-    - **input** (Variable) – detection的结果，一个 shape=[M, 6] 的 lodtensor。布局为[label, confidence, xmin, ymin, xmax, ymax]
-    - **gt_label** (Variable) – ground truth label 的索引，它是一个形状为[N, 1]的lodtensor
-    - **gt_box** (Variable) – ground truth bounds box (bbox)，是一个具有形状的lod张量[N, 4]。布局是[xmin, ymin, xmax, ymax]
-    - **gt_difficult** (Variable|None) – 指定这个ground truth是否是一个difficult bounding bbox，它可以是一个 shape=[N, 1]的LoDTensor，也可以不被指定。如果设置为None，则表示所有的ground truth标签都不是difficult bbox。
-    - **class_num** (int) – 检测类别的数目
+    - **input** (Variable) – detection的输出结果，一个 shape=[M, 6] 的 LoDtensor。布局为[label, confidence, xmin, ymin, xmax, ymax],label为类别标签，confidence为置信度，xmin，ymin为检测框左上点坐标，xmax，ymax为检测框右下点坐标，数据类型为float32或float64。
+    - **gt_label** (Variable) – ground truth label 的索引，它是一个形状为[N, 1]的LoDtensor，数据类型为float32或float64。
+    - **gt_box** (Variable) – ground truth bounds box (bbox)，是一个具有形状的LoD张量[N, 4]。布局是[xmin, ymin, xmax, ymax]，数据类型为float32或float64。
+    - **gt_difficult** (Variable|None, 可选) – 指定这个ground truth是否是一个difficult bounding bbox，它可以是一个 shape=[N, 1]的LoDTensor，也可以不被指定。默认设置为None，表示所有的ground truth标签都不是difficult bbox，数据类型为float32或float64。
+    - **class_num** (int) – 检测类别的数目。
    - **background_label** (int) – 背景标签的索引，背景标签将被忽略。如果设置为-1，则所有类别将被考虑，默认为0。
-    - **overlap_threshold** (float) – 判断真假阳性的阈值，默认为0.5
+    - **overlap_threshold** (float) – 判断真假阳性的阈值，默认为0.5。
    - **evaluate_difficult** (bool) – 是否考虑 difficult ground truth 进行评价，默认为 True。当 gt_difficult 为 None 时，这个参数不起作用。
-    - **ap_version** (string) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/tag/average-precision/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。
+    - **ap_version** (str) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/tag/average-precision/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。
+
+返回：变量(Variable) 计算mAP的结果，其中数据类型为float32或float64。
+
+返回类型：变量(Variable)
+

 **代码示例**

@@ -65,15 +70,15 @@ DetectionMAP

 .. py:method:: get_map_var()

-返回：当前 mini-batch 的 mAP 变量，和跨 mini-batch 的 mAP 累加和
+返回：当前 mini-batch 的 mAP 变量和不同 mini-batch 的 mAP 累加和

 .. py:method::  reset(executor, reset_program=None)

-在指定 batch 的每一 pass/user  开始时重置度量状态。
+在指定的 batch 结束或者用户指定的开始时重置度量状态。

 参数：
    - **executor** (Executor) – 执行reset_program的执行程序
-    - **reset_program** (Program|None) –  单一 program 的 reset 过程。如果设置为 None，将创建一个 program
+    - **reset_program** (Program|None, 可选) – 单个program 的 reset 过程。如果设置为 None，将创建一个 program