update doc for im2sequence , mean_iou, pad2d, range (#1279)

update cn doc for im2sequence , mean_iou, pad2d, range

doc/fluid/api_cn/layers_cn/im2sequence_cn.rst

@@ -5,26 +5,27 @@ im2sequence
 
 .. py:function:: paddle.fluid.layers.im2sequence(input, filter_size=1, stride=1, padding=0, input_image_size=None, out_stride=1, name=None)
 
-从输入张量中提取图像张量，与im2col相似，shape={input.batch_size * output_height * output_width, filter_size_H * filter_size_W * input.通道}。这个op使用filter / kernel扫描图像并将这些图像转换成序列。一个图片展开后的timestep的个数为output_height * output_width，其中output_height和output_width由下式计算:
+该OP使用 `filter` 扫描输入的Tensor并将输入Tensor转换成序列，返回值的 `shape={input.batch_size * output_height * output_width, filter_size_height* filter_size_width * input.channels}` 。返回值的timestep的个数为 `output_height * output_width` ， 每个timestep的维度是 `filter_size_height* filter_size_width * input.channels` 。其中 `output_height` 和 `output_width` 由以下式计算:
 
 
 .. math::
-                        output\_size=1+\frac{(2∗padding+img\_size−block\_size+stride-1)}{stride}
+    output\_height = 1 + \frac{padding\_up + padding\_down + input\_height - filter\_size\_height + stride\_height-1}{stride\_height} \\
+    output\_width = 1 + \frac{padding\_left + padding\_right + input\_width - filter\_size\_width + stride\_width-1}{stride\_width}
 
-每个timestep的维度为 :math:`block\_y * block\_x * input.channels` 。
+其中符号的意义如下所示。
 
 参数:
-  - **input** （Variable）- 输入张量，格式为[N, C, H, W]
-  - **filter_size** (int|tuple|None) - 滤波器大小。如果filter_size是一个tuple，它必须包含两个整数(filter_size_H, filter_size_W)。否则，过滤器将是一个方阵。
-  - **stride** (int|tuple) - 步长大小。如果stride是一个元组，它必须包含两个整数(stride_H、stride_W)。否则，stride_H = stride_W = stride。默认:stride = 1。
-  - **padding** (int|tuple) - 填充大小。如果padding是一个元组，它可以包含两个整数(padding_H, padding_W)，这意味着padding_up = padding_down = padding_H和padding_left = padding_right = padding_W。或者它可以使用(padding_up, padding_left, padding_down, padding_right)来指示四个方向的填充。否则，标量填充意味着padding_up = padding_down = padding_left = padding_right = padding Default: padding = 0。
-  - **input_image_size** (Variable) - 输入包含图像的实际大小。它的维度为[batchsize，2]。该参数可有可无，是用于batch上的预测。
-  - **out_stride** (int|tuple) - 通过CNN缩放图像。它可有可无，只有当input_image_size不为空时才有效。如果out_stride是tuple，它必须包含(out_stride_H, out_stride_W)，否则，out_stride_H = out_stride_W = out_stride。
-  - **name** (int) - 该layer的名称，可以忽略。
+  - **input** （Variable）- 类型为float32的4-D Tensor，格式为 `[N, C, H, W]` 。公式中 `input_height` 和 `input_width` 分别代表输入的高和宽。
+  - **filter_size** (int32 | List[int32]) - 滤波器大小。如果 `filter_size` 是一个List，它必须包含两个整数 `[filter_size_height, filter_size_width]` 。如果 `filter_size` 是一个int32, 则滤波器大小是 `[filter_size, filter_size]` , 默认值为1。
+  - **stride** (int32 | List[int32]) - 步长大小。如果stride是一个List，它必须包含两个整数 `[stride_height,stride_width]` 。如果stride是一个int32, 则步长大小是 `[stride, stride]` , 默认值为1。
+  - **padding** (int32 | List[int32]) - 填充大小。如果padding是一个List，它可以包含四个整数 `[padding_up, padding_left, padding_down, padding_right]` ，当包含两个整数 `[padding_height, padding_width]` 时，可展开为 `[padding_height, padding_width, padding_height, padding_width]` 。如果padding是一个int, 可展开为 `[padding, padding, padding, padding]` 。默认值为0。
+  - **input_image_size** (Variable, 可选) - 2-D Tensor, 输入图像的实际大小, 它的维度为 `[batchsize，2]` 。当该参数不为None时，可用于batch inference。默认值为None.
+  - **out_stride** (int32 | List[int32]) - 输出步长。只有当input_image_size不为None时才有效。如果out_stride是List，它必须包含 `[out_stride_height, out_stride_width]` ，如果out_stride是int32, 则可展开为 `[out_stride, out_stride]` ，默认值为1。
+  - **name** (str, 可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，缺省值为None。
 
-返回： LoDTensor shape为{batch_size * output_height * output_width, filter_size_H * filter_size_W * input.channels}。如果将输出看作一个矩阵，这个矩阵的每一行都是一个序列的step。
+返回： 数据类型为float32, `shape` 为 `{batch_size * output_height * output_width, filter_size_height * filter_size_width * input.channels}` 的 2-D LodTensor。
 
-返回类型: output
+返回类型: Variable
 
 ::
 

doc/fluid/api_cn/layers_cn/mean_iou_cn.rst

@@ -5,41 +5,34 @@ mean_iou
 
 .. py:function:: paddle.fluid.layers.mean_iou(input, label, num_classes)
 
-均值IOU（Mean  Intersection-Over-Union）是语义图像分割中的常用的评价指标之一，它首先计算每个语义类的IOU，然后计算类之间的平均值。定义如下:
+该OP计算均值IOU, 均值IOU（Mean  Intersection-Over-Union）是语义图像分割中的常用的评价指标之一，它首先计算每个类的IOU，然后计算类之间的平均值。IOU定义如下:
 
 .. math::
 
     IOU = \frac{true\_positive}{true\_positive+false\_positive+false\_negative}
 
-在一个confusion矩阵中累积得到预测值，然后从中计算均值-IOU。
+先得到类别的预测结果，然后从中计算均值-IOU。
 
 参数:
-    - **input** (Variable) - 类型为int32或int64的语义标签的预测结果张量。
-    - **label** (Variable) - int32或int64类型的真实label张量。它的shape应该与输入相同。
-    - **num_classes** (int) - 标签可能的类别数目。
+    - **input** (Variable) - 分割类别预测结果，类型为int32或int64的多维Tensor。
+    - **label** (Variable) - 真实label，类型为int32或int64的多维Tensor，它的shape与input相同。
+    - **num_classes** (int32) - 类别数目。
 
-返回: 返回三个变量:
+返回: 
+    - **mean_iou** (Variable) - 类型为float32的1-D Tensor，shape为[1]， 均值IOU的计算结果。
+    - **out_wrong** (Variable) - 类型为int32的1-D Tensor，shape为[num_classes]，代表每个类别中错误的个数。
+    - **out_correct** (Variable) - 类型为int32的1-D Tensor，shape为[num_classes]，代表每个类别中正确的个数。
 
-- mean_iou: 张量，形为[1]， 代表均值IOU。
-- out_wrong: 张量，形为[num_classes]。每个类别中错误的个数。
-- out_correct:张量，形为[num_classes]。每个类别中的正确的个数。
-
-返回类型:   mean_iou (Variable),out_wrong(Variable),out_correct(Variable)
 
 **代码示例**
 
 ..  code-block:: python
 
    import paddle.fluid as fluid
-   predict = fluid.layers.data(name='predict', shape=[3, 32, 32])
-   label = fluid.layers.data(name='label', shape=[1])
-   iou, wrongs, corrects = fluid.layers.mean_iou(predict, label, num_classes=5)
-
-
-
-
-
-
-
-
+   iou_shape = [32, 32]
+   num_classes = 5
+   predict = fluid.layers.data(name='predict', shape=iou_shape, dtype='int64')
+   label = fluid.layers.data(name='label', shape=iou_shape, dtype='int64')
+   mean_iou, out_wrong, out_correct = fluid.layers.mean_iou(predict, label, num_classes)
 
+    

doc/fluid/api_cn/layers_cn/pad2d_cn.rst

@@ -5,9 +5,21 @@ pad2d
 
 .. py:function::  paddle.fluid.layers.pad2d(input, paddings=[0, 0, 0, 0], mode='constant', pad_value=0.0, data_format='NCHW', name=None)
 
-依照 paddings 和 mode 属性对图像进行2维 ``pad``,如果mode是 ``reflection``，则paddings[0]和paddings[1]必须不大于height-1。宽度维数具有相同的条件。
+该OP依照 paddings 和 mode 属性对input进行2维 ``pad`` 。
 
-例如：
+参数：
+  - **input** (Variable) - 类型为float32的4-D Tensor， format为 `[N, C, H, W]` 或 `[N, H, W, C]` 。
+  - **paddings** (Variable | List[int32]) - 填充大小。如果paddings是一个List，它必须包含四个整数 `[padding_top, padding_bottom, padding_left, padding_right]` 。
+    如果paddings是Variable， 则是类型为int32 的1-D Tensor，shape是 `[4]` 。默认值为 `[0,0,0,0]` 。
+  - **mode** (str) - padding的三种模式，分别为 `'constant'` (默认)、 `'reflect'` 、 `'edge'` 。 `'constant'` 为填充常数 `pad_value` ， `'reflect'` 为填充以input边界值为轴的映射， `'edge'` 为填充input边界值。具体结果可见以下示例。默认值为 `'constant'` 。
+  - **pad_value** (float32) - 以 `'constant'` 模式填充区域时填充的值。默认值为0.0。
+  - **data_format** (str)  - 指定input的format，可为 `'NCHW'` 和 `'NHWC'` ，默认值为 `'NCHW'` 。
+  - **name** (str, 可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，缺省值为None。
+返回： 对input进行2维 ``pad`` 的结果，数据类型和input一样的4-D Tensor。
+
+返回类型：Variable
+
+示例：
 
 .. code-block:: text
 
@@ -38,18 +50,7 @@ pad2d
                [4, 4, 4, 5, 6, 6]
                [4, 4, 4, 5, 6, 6]]
 
-参数：
-  - **input** (Variable) - 具有[N, C, H, W]格式或[N, H, W, C]格式的输入图像。
-  - **paddings** (tuple|list|Variable) - 填充区域的大小。如果填充是一个元组，它必须包含四个整数，
-    (padding_top, padding_bottom, padding_left, padding_right)。默认:padding =[0,0,0,0]。
-  - **mode** (str) - 三种模式:constant(默认)、reflect、edge。默认值:常数
-  - **pad_value** (float32) - 以常量模式填充填充区域的值。默认值:0
-  - **data_format** (str)  - 可选字符串，选项有: ``NHWC`` , ``NCHW``。指定输入数据的数据格式。默认值:``NCHW``
-  - **name** (str|None) - 此层的名称(可选)。如果没有设置，该层将被自动命名。
 
-返回： tensor变量，按照 padding值 和 mode 进行填充
-
-返回类型：variable
 
 **代码示例：**
 
@@ -60,12 +61,3 @@ pad2d
   result = fluid.layers.pad2d(input=data, paddings=[1,2,3,4], mode='reflect')
 
 
-
-
-
-
-
-
-
-
-

doc/fluid/api_cn/layers_cn/range_cn.rst

@@ -5,18 +5,18 @@ range
 
 .. py:function:: paddle.fluid.layers.range(start, end, step, dtype)
 
-均匀分隔给定数值区间，并返回该分隔结果。
-
-返回值在半开区间[start，stop)内生成（即包括起点start但不包括终点stop的区间）。
+该OP根据step均匀分隔给定数值区间[start, end)，并返回该分隔结果。
 
 
 参数：
-    - **start** （int | float | Variable） - 区间起点，且区间包括此值。
-    - **end** （int | float | Variable） - 区间终点，通常区间不包括此值。但当step不是整数，且浮点数取整会影响out的长度时例外。
-    - **step** （int | float | Variable） - 返回结果中数值之间的间距（步长）。 对于任何输出变量out，step是两个相邻值之间的距离，即out [i + 1]  -  out [i]。 默认为1。
-    - **dtype** （string） - 'float32'|'int32'| ...，输出张量的数据类型。
+    - **start** （float32 | float64  | int32 | int64 | Variable） - 区间起点，且区间包括此值, 当类型是Variable时，是shape为 `[1]` 的1-D Tensor。
+    - **end**  （float32 | float64  | int32 | int64 | Variable） - 区间终点，通常区间不包括此值。但当step不是整数，且浮点数取整会影响输出的长度时例外。
+    - **step** （float32 | float64  | int32 | int64 | Variable） - 均匀分割的步长。
+    - **dtype** （str） - 输出Tensor的数据类型，可为 `'float32'`, `'float64'`, `'int32'`, `'int64'` 。
+
+返回：均匀分割给定数值区间后得到的1-D Tensor, 数据类型为输入 `dtype` 。
 
-返回：均匀分割给定数值区间后得到的值组
+返回类型：Variable
 
 
 **代码示例**：