fix chinese document of 11 apis (#1357)

* fix api_cn of 11 APIs
test=develop
test=document_preview

* fix format of math and params

* fix tensor dimension description

doc/fluid/api_cn/layers_cn/clip_cn.rst

@@ -5,22 +5,23 @@ clip
 
 .. py:function:: paddle.fluid.layers.clip(x, min, max, name=None)
 
-clip算子
-
-clip算子限制给定输入的值在一个区间内。间隔使用参数"min"和"max"来指定：公式为
+该OP对输入Tensor每个元素的数值进行裁剪，使得输出Tensor元素的数值被限制在区间[min, max]内。具体的计算公式为如下。
 
 .. math::
-        Out=min(max(X,min),max)
+
+  Out = MIN(MAX(x,min),max)
+
+
 
 参数：
-        - **x** （Variable）- （Tensor）clip运算的输入，维数必须在[1,9]之间。
-        - **min** （FLOAT）- （float）最小值，小于该值的元素由min代替。
-        - **max** （FLOAT）- （float）最大值，大于该值的元素由max替换。
-        - **name** （basestring | None）- 输出的名称。
+        - **x** (Variable)- 多维Tensor，数据类型为float32
+        - **min** (float)- 最小值，输入Tensor中小于该值的元素由min代替。
+        - **max** (float)- 最大值，输入Tensor中大于该值的元素由max替换。
+        - **name** (None|str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回：        （Tensor）clip操作后的输出和输入（X）具有形状（shape）
+返回：  对元素的数值进行裁剪之后的Tesnor，与输入x具有相同的shape和数据类型
 
-返回类型：        输出（Variable）。
+返回类型：Variable
 
 **代码示例：**
 

doc/fluid/api_cn/layers_cn/crop_cn.rst

@@ -5,9 +5,9 @@ crop
 
 .. py:function:: paddle.fluid.layers.crop(x, shape=None, offsets=None, name=None)
 
-根据偏移量（offsets）和形状（shape），裁剪输入张量。
+该OP根据偏移量(offsets)和形状(shape)，裁剪输入张量。
 
-**注意:** 此功能已被弃用，它将在以后的版本中被删除。更新说明：使用 `fluid.layers.crop_tensor <https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/layers_cn/nn_cn.html#crop_tensor>`_ 替代。
+**注意:** 此OP已被弃用，它将在以后的版本中被删除，请使用 :ref:`cn_api_fluid_layers_crop_tensor` 替代
 
 **样例**：
 
@@ -41,16 +41,16 @@ crop
 
 
 参数:
-  - **x** (Variable): 输入张量。
-  - **shape** (Variable|list/tuple of integer) - 输出张量的形状由参数shape指定，它可以是一个变量/整数的列表/整数元组。如果是张量变量，它的秩必须与x相同。该方式适可用于每次迭代时候需要改变输出形状的情况。如果是整数列表/tupe，则其长度必须与x的秩相同
-  - **offsets** (Variable|list/tuple of integer|None) - 指定每个维度上的裁剪的偏移量。它可以是一个Variable，或者一个整数list/tupe。如果是一个tensor variable，它的rank必须与x相同，这种方法适用于每次迭代的偏移量（offset）都可能改变的情况。如果是一个整数list/tupe，则长度必须与x的rank的相同，如果shape=None，则每个维度的偏移量为0。
-  - **name** (str|None) - 该层的名称(可选)。如果设置为None，该层将被自动命名。
+  - **x** (Variable): 多维Tensor，数据类型为float32
+  - **shape** (Variable|list/tuple of integers) - 指定输出Tensor的形状，它可以是一个Tensor/整数列表/整数元组。如果是Tensor，它的秩必须与x相同，它的形状指定了输出Tensor的形状，它的元素的数值在这里不起作用，该方式适用于每次迭代时候需要改变输出形状的情况。如果是整数列表/元组，则其长度必须与x的秩相同
+  - **offsets** (Variable|list/tuple of integers|None，可选) - 指定每个维度上的裁剪的偏移量，它可以是一个Tensor，或者一个整数列表/整数元组。如果是一个Tensor，它的秩必须与x相同，这种方法适用于每次迭代的偏移量（offset）都可能改变的情况。如果是一个整数列表/元组，则长度必须与x的秩相同，如果offsets=None，则每个维度的偏移量为0。默认值为None
+  - **name** (str|None，可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回: 裁剪张量。
+返回: 经过形状裁剪之后的Tensor，与输入x具有相同的数据类型
 
-返回类型: 变量（Variable）
+返回类型: Variable
 
-抛出异常: 如果形状不是列表、元组或变量，抛出ValueError
+抛出异常: 如果形状不是列表、元组或Variable，抛出ValueError
 
 
 **代码示例**:
@@ -58,12 +58,17 @@ crop
 ..  code-block:: python
     
     import paddle.fluid as fluid
+    # case 1
+    # 输入x的形状为[-1, 3, 5]，
+    # 参数shape = y是个Variable，形状是[-1, 2, 2]，输出Tensor将具有和y一样的形状
+    # y的具体数值不起作用，起作用的只有它的形状
+    # 经过下面的crop操作之后输出张量的形状是: [-1, 2, 2]
     x = fluid.layers.data(name="x", shape=[3, 5], dtype="float32")
-    y = fluid.layers.data(name="y", shape=[2, 3], dtype="float32")
+    y = fluid.layers.data(name="y", shape=[2, 2], dtype="float32")
     crop = fluid.layers.crop(x, shape=y)
-
-
-    ## or
+    ## 或者 case 2
+    # 输入z的形状为: [-1, 3, 5], shape为整数列表[-1, 2, 3]
+    # 则经过下面的crop操作之后输出张量的形状为：[-1, 2, 3]
     z = fluid.layers.data(name="z", shape=[3, 5], dtype="float32")
     crop = fluid.layers.crop(z, shape=[-1, 2, 3])
 

doc/fluid/api_cn/layers_cn/ctc_greedy_decoder_cn.rst

@@ -5,12 +5,14 @@ ctc_greedy_decoder
 
 .. py:function:: paddle.fluid.layers.ctc_greedy_decoder(input, blank, name=None)
 
-此op用于贪婪策略解码序列，步骤如下:
+**注意：该OP的输入input必须是2维LoDTensor, lod_level为1** 
+
+该OP用于贪婪策略解码序列，步骤如下:
     1. 获取输入中的每一行的最大值索引，也就是numpy.argmax(input, axis=0)。
-    2. 对于step1结果中的每个序列，在两个空格之间合并重复部分（即合并重复的上一步中的到的索引值）并删除所有空格。
+    2. 对于step1结果中的每个序列，合并两个空格之间的重复部分并删除所有空格。
 
 
-简单举一个例子，
+**样例**：
 
 ::
 
@@ -45,13 +47,13 @@ ctc_greedy_decoder
 
 
 参数:
-        - **input** (Variable) — (LoDTensor<float>)，变长序列的概率，它是一个具有LoD信息的二维张量。它的形状是[Lp, num_classes + 1]，其中Lp是所有输入序列长度的和，num_classes是真正的类别。(不包括空白标签)。
-        - **blank** (int) — Connectionist Temporal Classification (CTC) loss空白标签索引,  属于半开区间[0,num_classes + 1）。
-        - **name** (str) — 此层的名称。可选。
+        - **input** (Variable) — 变长序列的概率，2维LoDTensor, lod_level为1。它的形状是[Lp, num_classes + 1]，其中Lp是所有输入序列长度的和，num_classes是类别数目(不包括空白标签)。数据类型是float32或者float64
+        - **blank** (int) — Connectionist Temporal Classification (CTC) loss空白标签索引,  其数值属于半开区间[0,num_classes + 1）
+        - **name** (str) — (str|None，可选) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None
 
-返回： CTC贪婪解码结果是一个形为(Lp,1)的二维张量，其中Lp是所有输出序列的长度之和。如果结果中的所有序列都为空，则输出LoDTensor 为[-1]，其中LoD[[]] 形为[1,1]。
+返回： CTC贪婪解码结果是一个形为(Lp,1)的2维LoDTensor，lod_level为1，其中Lp是所有输出序列的长度之和。如果结果中的所有序列都为空，则输出LoDTensor为[-1]，其lod信息为空。
 
-返回类型： 变量（Variable）
+返回类型： Variable
 
 
 **代码示例**
@@ -60,7 +62,6 @@ ctc_greedy_decoder
 
     import paddle.fluid as fluid
     x = fluid.layers.data(name='x', shape=[8], dtype='float32')
-
     cost = fluid.layers.ctc_greedy_decoder(input=x, blank=0)
 
 

doc/fluid/api_cn/layers_cn/dice_loss_cn.rst

@@ -5,7 +5,7 @@ dice_loss
 
 .. py:function:: paddle.fluid.layers.dice_loss(input, label, epsilon=1e-05)
 
-dice_loss是比较两批数据相似度，通常用于二值图像分割，即标签为二值。
+该OP用来比较预测结果跟标签之间的相似度，通常用于二值图像分割，即标签为二值，也可以做多标签的分割。
 
 dice_loss定义为:
 
@@ -15,13 +15,13 @@ dice_loss定义为:
                    &= \frac{union\_area−intersection\_area}{total\_area}
 
 参数:
-    - **input** (Variable) - rank>=2的预测。第一个维度是batch大小，最后一个维度是类编号。
-    - **label** （Variable）- 与输入tensor rank相同的正确的标注数据（groud truth）。第一个维度是batch大小，最后一个维度是1。
-    - **epsilon** (float) - 将会加到分子和分母上。如果输入和标签都为空，则确保dice为1。默认值:0.00001
+    - **input** (Variable) - 分类的预测概率，秩大于等于2的多维Tensor，维度为 :math:`[N_1, N_2, ..., N_k, D]` 。第一个维度的大小是batch_size，最后一维的大小D是类别数目。数据类型是float32或者float64
+    - **label** (Variable)- 正确的标注数据(groud truth)，与输入 ``input`` 的秩相同的Tensor，维度为 :math:`[N_1, N_2, ..., N_k, 1]` 。第一个维度的大小是batch_size，最后一个维度的大小是1。数据类型为int32或者int64
+    - **epsilon** (float，可选) - 将会加到分子和分母上的数，浮点型的数值。如果输入和标签都为空，则确保dice为1。默认值:0.00001
 
-返回: dice_loss shape为[1]。
+返回: 按上述公式计算出来的损失函数的结果所表示的Tensor，shape为[batch_size, 1]，数据类型与 ``input`` 相同
 
-返回类型:  dice_loss(Variable)
+返回类型:  Variable
 
 **代码示例**
 
@@ -41,5 +41,3 @@ dice_loss定义为:
 
 
 
-
-

doc/fluid/api_cn/layers_cn/pad_cn.rst

@@ -5,10 +5,10 @@ pad
 
 .. py:function:: paddle.fluid.layers.pad(x, paddings, pad_value=0.0, name=None)
 
-在张量上加上一个由 ``pad_value`` 给出的常数值，填充宽度由 ``paddings`` 指定。
-其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2i+1]`` 表示。
+该OP在Tensor上填充一个由 ``pad_value`` 给出的常数值，填充宽度由 ``paddings`` 指定。
+其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2*i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2*i+1]`` 表示。
 
-一个例子:
+**样例**：
 
 ::
 
@@ -28,14 +28,14 @@ pad
 
 
 参数:
-    - **x** (Variable) — —输入张量变量。
-    - **paddings** (list) — 一个整数列表。按顺序填充在每个维度上填充元素。 ``padding`` 长度必须是 ``rank(x)×2``
-    - **pad_value** (float) — 用来填充的常量值。
-    - **name** (str|None) — 这个层的名称(可选)。如果设置为None，该层将被自动命名。
+    - **x** (Variable) — 多维Tensor，数据类型为float32
+    - **paddings** (list of integers) — 整数列表，指定每个维度填充值的个数。维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2*i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2*i+1]`` 表示。 ``paddings`` 长度必须是 ``rank(x)×2``
+    - **pad_value** (float32, 可选) — 用来填充的常量值，数据类型为float。默认值为0.
+    - **name** (str|None) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回： 填充后的张量变量
+返回： 填充后的Tensor，数据类型与输入 ``x`` 相同
 
-返回类型： 变量（Variable）
+返回类型： Variable
 
 
 **代码示例**
@@ -45,8 +45,7 @@ pad
     # x 为一个秩为2的张量
     import paddle.fluid as fluid
     x = fluid.layers.data(name='data', shape=[224], dtype='float32')
-    out = fluid.layers.pad(
-        x=x, paddings=[0, 1, 1, 2], pad_value=0.)
+    out = fluid.layers.pad(x=x, paddings=[0, 1, 1, 2], pad_value=0.)
 
 
 

doc/fluid/api_cn/layers_cn/pad_constant_like_cn.rst

@@ -5,9 +5,9 @@ pad_constant_like
 
 .. py:function:: paddle.fluid.layers.pad_constant_like(x, y, pad_value=0.0, name=None)
 
-使用 ``pad_value`` 填充 ``Y`` ，填充到每个axis（轴）值的数量由X和Y的形不同而指定。（（0，shape_x_0 - shape_y_0），...（0，shape_x_n - shape_y_n ））是每个axis唯一pad宽度。输入应该是k维张量（k> 0且k <7）。
+该OP使用 ``pad_value`` 填充 ``y`` ，填充到每个维度值的数量由x和y的形状而指定，((0，x.shape[0] - y.shape[0]), ..., (0, x.shape[i] - y.shape[i]), ..., (0, x.shape[n] - y.shape[n]))是每个维度填充的宽度，对于维度i，填充宽度 ``(0, x.shape[i] - y.shape[i])`` ，表示在y的第i维开头不填充，而在末尾填充 ``x.shape[i] - y.shape[i]`` 个位置。该OP要求y与x具有相同的秩，并且对每个维度i， ``y.shape[i] <= x.shape[i]`` 。
 
-**实例如下**
+**样例**
 
 ::
 
@@ -31,15 +31,33 @@ pad_constant_like
               [[41, 42, 43]]]]
         Y.shape = (1, 3, 1, 3)
 
+    and
+        pad_value = 0.
+
+    Output is:
+        out = [[[[35, 36, 37],
+                 [0, 0, 0]],
+                [[38, 39, 40],
+                 [0, 0, 0]],
+                [[41, 42, 43],
+                 [0, 0, 0]]],
+               [[[0, 0, 0], 
+                 [0, 0, 0]],
+                [[0, 0, 0], 
+                 [0, 0, 0]],
+                [[0, 0, 0], 
+                 [0, 0, 0]]]]
+        out.shape = [2, 3, 2, 3]
+
 参数：
-          - **x** （Variable）- 输入Tensor变量。
-          - **y** （Variable）- 输出Tensor变量。
-          - **pad_value** (float) - 用于填充的常量值。
-          - **name** （str | None） - 这一层的名称（可选）。如果设置为None，则将自动命名这一层。
+          - **x** （Variable）- 多维Tensor
+          - **y** （Variable）- 多维Tensor，与x具有相同的秩，而且对任意维度 ``i`` ，要求满足 ``y.shape[i] <= x.shape[i]`` 。数据类型为float32或float64
+          - **pad_value** (float，可选) - 用于填充的常量值。默认值为0.
+          - **name** （str | None） - (str|None) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回：填充张量（Tensor）变量
+返回：经过维度填充后的Tensor，与x具有相同的shape，与y具有相同的数据类型
 
-返回类型：  变量（Variable）
+返回类型：  Variable
 
 **示例代码**
 

doc/fluid/api_cn/layers_cn/psroi_pool_cn.rst

@@ -5,24 +5,38 @@ psroi_pool
 
 .. py:function:: paddle.fluid.layers.psroi_pool(input, rois, output_channels, spatial_scale, pooled_height, pooled_width, name=None)
 
-PSROIPool运算
+**注意 rois必须为2维LoDTensor，lod_level为1**
 
-区分位置的感兴趣区域池化方法（Position sensitive region of interest pooling，也称为PSROIPooling）是对输入的 "感兴趣区域"(RoI)执行按位置的average池化，并将N个按位置评分图（score map）和一个由num_rois个感兴趣区域所组成的列表作为输入。
+该OP执行PSROIPooling运算，是位置敏感的感兴趣区域池化方法（Position sensitive region of interest pooling，也称为PSROIPooling）。输入input是位置敏感的评分图，输入rois是感兴趣区域的位置坐标。PSROIPooling不同于普通ROIPooling的地方在于，输入input特征图的不同通道会跟输出特征图上的位置区域相关联，该方法是在R-FCN模型中首次提出来的，更多详细信息请参阅 https://arxiv.org/abs/1605.06409。
+
+
+**样例**：
+
+::
+
+      Given:
+        input.shape = [2, 490, 28, 28]
+        rois.shape = [5, 4], rois.lod = [[3, 2]]
+        output_channels = 10
+        pooled_height = 7
+        pooled_width = 7
+
+      Return:
+        out.shape = [5, 10, 7, 7], out.lod = [[3, 2]]
 
-用于R-FCN的PSROIPooling。 有关更多详细信息，请参阅 https://arxiv.org/abs/1605.06409。
 
 参数：
-    - **input** （Variable） - （Tensor），PSROIPoolOp的输入。 输入张量的格式是NCHW。 其中N是批大小batch_size，C是输入通道的数量，H是输入特征图的高度，W是特征图宽度
-    - **rois** （Variable） - 要进行池化的RoI（感兴趣区域）。应为一个形状为(num_rois, 4)的二维LoDTensor，其lod level为1。给出[[x1, y1, x2, y2], ...]，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标。
-    - **output_channels** （integer） - （int），输出特征图的通道数。 对于共C个种类的对象分类任务，output_channels应该是（C + 1），该情况仅适用于分类任务。
-    - **spatial_scale** （float） - （float，default 1.0），乘法空间比例因子，用于将ROI坐标从其输入比例转换为池化使用的比例。默认值：1.0
-    - **pooled_height** （integer） - （int，默认值1），池化输出的高度。默认值：1
-    - **pooled_width** （integer） - （int，默认值1），池化输出的宽度。默认值：1
-    - **name** （str，default None） - 此层的名称。
+    - **input** (Variable) - 输入特征图，4-D Tensor，格式是NCHW。 其中N是batch_size，C是输入通道的数量，H是输入特征图的高度，W是特征图宽度。数据类型是float32或者float64
+    - **rois** (Variable) - 感兴趣区域，2-D LoDTensor，形状为(num_rois, 4)，lod_level为1。形式如[x1, y1, x2, y2], ...]，其中(x1, y1)为左上角坐标，(x2, y2)为右下角坐标。数据类型与input相同
+    - **output_channels** (int) - 输出特征图的通道数。对于共C个种类的图像分类任务，output_channels应该是 ``(C + 1)`` ，其中1代表背景
+    - **spatial_scale** (float) - 空间跨度因子，用于将 ``rois`` 中的坐标从其输入尺寸按比例映射到 ``input`` 特征图的尺寸
+    - **pooled_height** (int) - 池化输出的高度
+    - **pooled_width** (int) - 池化输出的宽度
+    - **name** (str|None) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回： （Tensor），PSROIPoolOp的输出是形为 (num_rois，output_channels，pooled_h，pooled_w) 的4-D Tensor。
+返回： 经过PSROIPooling之后的结果，形状为(num_rois，output_channels，pooled_height，pooled_width) 的4维LoDTensor，lod_level为1，数据类型与input相同，与rois具有相同的lod信息。
 
-返回类型：  变量（Variable）
+返回类型：  Variable
 
 **代码示例：**
 

doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst

@@ -5,22 +5,21 @@ roi_perspective_transform
 
 .. py:function:: paddle.fluid.layers.roi_perspective_transform(input, rois, transformed_height, transformed_width, spatial_scale=1.0)
 
-**ROI perspective transform操作符**
+该OP对RoI区域做透视变换，将不规则的RoI区域变成固定大小的矩形区域，透视变换是线性代数里面的一种基础变换。
 
 参数：
-    - **input** (Variable) - ROI Perspective TransformOp的输入。输入张量的形式为NCHW。N是批尺寸，C是输入通道数，H是特征高度，W是特征宽度
-    - **rois** (Variable) - 用来处理的ROIs，应该是shape的二维LoDTensor(num_rois,8)。给定[[x1,y1,x2,y2,x3,y3,x4,y4],...],(x1,y1)是左上角坐标，(x2,y2)是右上角坐标，(x3,y3)是右下角坐标，(x4,y4)是左下角坐标
-    - **transformed_height** (integer) - 输出的高度
-    - **transformed_width** (integer) – 输出的宽度
-    - **spatial_scale** (float) - 空间尺度因子，用于缩放ROI坐标，默认：1.0。
-
-返回：
-三变量的一个元组。 (out, mask, transform_matrix)
- - ``out`` : ``ROIPerspectiveTransformOp`` 的输出，它是一个4维张量，形为 (num_rois,channels,transformed_h,transformed_w)。
- - ``mask`` : ``ROIPerspectiveTransformOp`` 的掩码，它是一个4维张量，形为 (num_rois,1,transformed_h,transformed_w)。
- - ``transform_matrix`` : ``ROIPerspectiveTransformOp`` 的转换矩阵，它是一个2维张量，形为 (num_rois,9)。
-
-返回类型：元组
+    - **input** (Variable) - 输入特征图，4-D Tensor，格式为NCHW。N是batch_size，C是输入通道数，H是特征图高度，W是特征图宽度。数据类型是float32
+    - **rois** (Variable) - 感兴趣区域，2D-LoDTensor，形状是(num_rois,8)，lod_level为1。其数据形式是[[x1,y1,x2,y2,x3,y3,x4,y4], ...]，其中(x1,y1)是左上角坐标，(x2,y2)是右上角坐标，(x3,y3)是右下角坐标，(x4,y4)是左下角坐标。数据类型与 ``input`` 相同
+    - **transformed_height** (int) - 输出的高度
+    - **transformed_width** (int) – 输出的宽度
+    - **spatial_scale** (float，可选) - 空间尺度因子，用于缩放ROI坐标，浮点数。默认值1.0
+
+返回： 由三个变量构成的元组 (out, mask, transform_matrix)
+ - ``out`` : ``ROIPerspectiveTransformOp`` 的输出，4D-LoDTensor，形状是(num_rois,channels,transformed_height,transformed_width)，lod_level为1
+ - ``mask`` : ``ROIPerspectiveTransformOp`` 的掩码，4D-LoDTensor，形状是(num_rois,1,transformed_height,transformed_width)，lod_level为1
+ - ``transform_matrix`` : ``ROIPerspectiveTransformOp`` 的转换矩阵，2D-LoDTensor，形状是(num_rois,9)，lod_level为1
+
+返回类型：  元组
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/unfold_cn.rst

@@ -5,8 +5,7 @@ unfold
 
 .. py:function:: paddle.fluid.layers.unfold(x, kernel_size, strides=1, paddings=0, dilation=1, name=None)
 
-该函数会将在输入 ``x`` 上滑动的filter block转换为一列缓存数据。对于每一个卷积过滤器下的block，下面的元素都会被重新排成一列，当滑动的卷积过滤器走过整个特征图时，将会形成一系列的列。
-对于每一个输入形为[N, C, H, W]的 ``x`` ，都将会按照下面公式计算出一个形为[N, Cout, Lout]的输出。
+该OP实现的功能与卷积中用到的im2col函数一样，通常也被称作为im2col过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的 ``x`` ，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
 
 
 ..  math::
@@ -23,18 +22,32 @@ unfold
 
        Lout &= hout * wout
 
+**样例**：
+
+::
+
+      Given:
+        x.shape = [5, 10, 25, 25]
+        kernel_size = [3, 3]
+        strides = 1
+        paddings = 1
+
+      Return:
+        out.shape = [5, 90, 625]
+
+
 参数：
-    - **x**  (Variable) – 格式为[N, C, H, W]的输入张量 
-    - **kernel_size**  (int|list) – 卷积核的尺寸，应该为[k_h, k_w],或者为一个整型k，处理为[k, k]
-    - **strides**  (int|list) – 卷积步长，应该为[stride_h, stride_w],或者为一个整型stride，处理为[stride, stride],默认为[1, 1]
-    - **paddings** (int|list) – 每个维度的扩展, 应该为[padding_top, padding_left，padding_bottom, padding_right]或者[padding_h, padding_w]或者一个整型padding。如果给了[padding_h, padding_w],则应该被扩展为[padding_h, padding_w, padding_h, padding_w]. 如果给了一个整型的padding，则会使用[padding, padding, padding, padding]，默认为[0, 0, 0, 0]
-    - **dilations** (int|list) – 卷积膨胀，应当为[dilation_h, dilation_w]，或者一个整型的dilation处理为[dilation, dilation]。默认为[1, 1]。
+    - **x**  (Variable) – 输入4-D Tensor，形状为[N, C, H, W]，数据类型为float32或者float64
+    - **kernel_size**  (int|list of int) – 卷积核的尺寸，整数或者整型列表。如果为整型列表，应包含两个元素 ``[k_h, k_w]`` ，卷积核大小为 ``k_h * k_w`` ；如果为整数k，会被当作整型列表 ``[k, k]`` 处理
+    - **strides**  (int|list of int，可选) – 卷积步长，整数或者整型列表。如果为整型列表，应该包含两个元素 ``[stride_h, stride_w]`` 。如果为整数，则 ``stride_h = stride_w = strides`` 。默认值为1
+    - **paddings** (int|list of int，可选) – 每个维度的扩展, 整数或者整型列表。如果为整型列表，长度应该为4或者2；长度为4 对应的padding参数是：[padding_top, padding_left，padding_bottom, padding_right]，长度为2对应的padding参数是[padding_h, padding_w]，会被当作[padding_h, padding_w, padding_h, padding_w]处理。如果为整数padding，则会被当作[padding, padding, padding, padding]处理。默认值为0
+    - **dilations** (int|list of int，可选) – 卷积膨胀，整型列表或者整数。如果为整型列表，应该包含两个元素[dilation_h, dilation_w]。如果是整数dilation，会被当作整型列表[dilation, dilation]处理。默认值为1
+    - **name** (str|None，可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
 
 
-返回： 
-    滑动block的输出张量，形状如上面所描述的[N, Cout, Lout]，Cout每一个滑动block里面值的总数，Lout是滑动block的总数.
+返回：   unfold操作之后的结果，形状如上面所描述的[N, Cout, Lout]，Cout每一个滑动block里面覆盖的元素个数，Lout是滑动block的个数，数据类型与 ``x`` 相同
 
-返回类型：（Variable）
+返回类型：    Variable
 
 **代码示例**:
 

doc/fluid/api_cn/nets_cn/sequence_conv_pool_cn.rst

@@ -5,21 +5,24 @@ sequence_conv_pool
 
 .. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max', bias_attr=None)
 
-sequence_conv_pool由序列卷积和池化组成
+**注意：该OP的输入** ``input`` **必须是2维LoDTensor, lod_level为1，如果输入是Tensor，建议使用** :ref:`cn_api_fluid_nets_simple_img_conv_pool` **代替**
+
+该接口由序列卷积( :ref:`cn_api_fluid_layers_sequence_conv` )和池化( :ref:`cn_api_fluid_layers_sequence_pool` )组成
 
 参数：
-    - **input** (Variable) - sequence_conv的输入，支持变量时间长度输入序列。当前输入为shape为（T，N）的矩阵，T是mini-batch中的总时间步数，N是input_hidden_size
-    - **num_filters** （int）- 滤波器数
-    - **filter_size** （int）- 滤波器大小
-    - **param_attr** （ParamAttr) - Sequence_conv层的参数。默认：None
-    - **act** （str） - Sequence_conv层的激活函数类型。默认：sigmoid
-    - **pool_type** （str）- 池化类型。可以是max-pooling的max，average-pooling的average，sum-pooling的sum，sqrt-pooling的sqrt。默认max
-    - **bias_attr** (ParamAttr|bool|None) – sequence_conv偏置的参数属性。如果设置为False，则不会向输出单元添加偏置。如果将参数设置为ParamAttr的None或one属性，sequence_conv将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化器，则初始化偏差为零。默认值:None。
+    - **input** (Variable) - sequence_conv的输入，LoDTensor, lod_level为1，支持时间长度可变的输入序列。当前输入为shape为（T，N）的矩阵，T是mini-batch中的总时间步数，N是input_hidden_size。数据类型为float32或者float64
+    - **num_filters** (int)- 卷积核的数目，整数
+    - **filter_size** (int)- 卷积核的大小，整数
+    - **param_attr** (ParamAttr，可选) - sequence_conv层的参数属性，类型是ParamAttr或者None。默认值为None
+    - **act** (str|None，可选) - sequence_conv层的激活函数类型，字符串，可以是'relu', 'softmax', 'sigmoid'等激活函数的类型。如果设置为None，则不使用激活。默认值为'sigmoid'
+    - **pool_type** (str，可选) - 池化类型，字符串。可以是'max', 'average', 'sum'或者'sqrt'。默认值为'max'
+    - **bias_attr** (ParamAttr|bool，可选) – sequence_conv偏置的参数属性，类型可以是bool，ParamAttr或者None。如果设置为False，则不会向输出单元添加偏置。如果将参数设置为ParamAttr的None或one属性，sequence_conv将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化器，则初始化偏差为零。默认值为None
+    - **name** (str|None，可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None
 
-返回：序列卷积（Sequence Convolution）和池化（Pooling）的结果
+返回：经过sequence_conv和sequence_pool两个操作之后的结果所表示的Tensor，数据类型与 ``input`` 相同
 
 
-返回类型：变量（Variable）
+返回类型：Variable
 
 **代码示例**：
 

doc/fluid/api_cn/nets_cn/simple_img_conv_pool_cn.rst

@@ -5,35 +5,38 @@ simple_img_conv_pool
 
 .. py:function:: paddle.fluid.nets.simple_img_conv_pool(input, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type='max', global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1, param_attr=None, bias_attr=None, act=None, use_cudnn=True)
 
- ``simple_img_conv_pool`` 由一个Convolution2d和一个Pool2d组成。
+ ``simple_img_conv_pool`` 由一个conv2d( :ref:`cn_api_fluid_layers_conv2d` )和一个pool2d( :ref:`cn_api_fluid_layers_pool2d` ) OP组成。
 
 参数：
-    - **input** （Variable） - 输入图像的格式为[N，C，H，W]。
-    - **num_filters** （int） - ``filter`` 的数量。它与输出的通道相同。
-    - **filter_size** （int | list | tuple） - 过滤器大小。如果 ``filter_size`` 是列表或元组，则它必须包含两个整数（filter_size_H，filter_size_W）。否则，filter_size_H = filter_size_W = filter_size。
-    - **pool_size** （int | list | tuple） - Pool2d池化层大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
-    - **pool_stride** （int | list | tuple） - Pool2d池化层步长。如果pool_stride是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。
-    - **pool_padding** （int | list | tuple） - Pool2d池化层的padding。如果pool_padding是列表或元组，则它必须包含两个整数（pool_padding_H，pool_padding_W）。否则，pool_padding_H = pool_padding_W = pool_padding。默认值为0。
-    - **pool_type** （str） - 池化类型可以是 ``max-pooling`` 的 ``max`` 和平均池的 ``avg`` 。默认 ``max`` 。
-    - **global_pooling** （bool）- 是否使用全局池。如果global_pooling = true，则忽略pool_size和pool_padding。默认为False
-    - **conv_stride** （int | list | tuple） - conv2d Layer的步长。如果stride是列表或元组，则它必须包含两个整数，（conv_stride_H，conv_stride_W）。否则，conv_stride_H = conv_stride_W = conv_stride。默认值：conv_stride = 1。
-    - **conv_padding** （int | list | tuple） - conv2d Layer的padding大小。如果padding是列表或元组，则它必须包含两个整数（conv_padding_H，conv_padding_W）。否则，conv_padding_H = conv_padding_W = conv_padding。默认值：conv_padding = 0。
-    - **conv_dilation** （int | list | tuple） - conv2d Layer的dilation大小。如果dilation是列表或元组，则它必须包含两个整数（conv_dilation_H，conv_dilation_W）。否则，conv_dilation_H = conv_dilation_W = conv_dilation。默认值：conv_dilation = 1。
-    - **conv_groups** （int） - conv2d Layer的组数。根据Alex Krizhevsky的Deep CNN论文中的分组卷积：当group = 2时，前半部分滤波器仅连接到输入通道的前半部分，而后半部分滤波器仅连接到后半部分输入通道。默认值：groups = 1。
-    - **param_attr** （ParamAttr | None） - 可学习参数的参数属性或conv2d权重。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为param_attr。如果未设置param_attr的初始化，则使用 :math:`Normal（0.0，std）` 初始化参数，并且 ``std`` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}` 。默认值:None
-    - **bias_attr** （ParamAttr | bool | None） - conv2d的bias参数属性。如果设置为False，则不会向输出单元添加bias。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化程序，则将偏差初始化为零。默认值：None
-    - **act** （str） - conv2d的激活类型，如果设置为None，则不附加激活。默认值：无。
-    - **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True。
-
-返回： Convolution2d和Pool2d之后输入的结果。
-
-返回类型：  变量（Variable）
+    - **input** (Variable) - 输入图像, 4-D Tensor, 格式为[N，C，H，W]。数据类型是float32或者float64
+    - **num_filters** (int) - 卷积核的数目，整数。
+    - **filter_size** (int | list | tuple) - conv2d卷积核大小，整数或者整型列表或者整型元组。如果 ``filter_size`` 是列表或元组，则它必须包含两个整数(filter_size_H，filter_size_W)。如果是整数，则filter_size_H = filter_size_W = filter_size。
+    - **pool_size** (int | list | tuple) - pool2d池化层大小，整数或者整型列表或者整型元组。如果pool_size是列表或元组，则它必须包含两个整数(pool_size_H，pool_size_W)。如果是整数，则pool_size_H = pool_size_W = pool_size。
+    - **pool_stride** (int | list | tuple) - pool2d池化层步长，整数或者整型列表或者整型元组。如果pool_stride是列表或元组，则它必须包含两个整数(pooling_stride_H，pooling_stride_W)。如果是整数，pooling_stride_H = pooling_stride_W = pool_stride。
+    - **pool_padding** (int | list | tuple，可选) - pool2d池化层的padding，整数或者整型列表或者整型元组。如果pool_padding是列表或元组，则它必须包含两个整数(pool_padding_H，pool_padding_W)。如果是整数，pool_padding_H = pool_padding_W = pool_padding。默认值为0。
+    - **pool_type** (str，可选) - 池化类型，字符串，可以是 ``max`` 或者 ``avg`` ，分别对应最大池化和平均池化。默认 ``max`` 。
+    - **global_pooling** (bool，可选)- 是否使用全局池化。如果global_pooling = true，则忽略pool_size和pool_padding。默认为False
+    - **conv_stride** (int | list | tuple，可选) - conv2d Layer的卷积步长，整数或者整型列表或者整型元组。如果conv_stride是列表或元组，则它必须包含两个整数，(conv_stride_H，conv_stride_W)。如果是整数，conv_stride_H = conv_stride_W = conv_stride。默认值：conv_stride = 1。
+    - **conv_padding** (int | list | tuple，可选) - conv2d Layer的padding大小，整数或者整型列表或者整型元组。如果conv_padding是列表或元组，则它必须包含两个整数(conv_padding_H，conv_padding_W)。如果是整数，conv_padding_H = conv_padding_W = conv_padding。默认值：conv_padding = 0。
+    - **conv_dilation** (int | list | tuple，可选) - conv2d Layer的dilation大小，整数或者整型列表或者整型元。如果conv_dilation是列表或元组，则它必须包含两个整数(conv_dilation_H，conv_dilation_W)。如果是整数，conv_dilation_H = conv_dilation_W = conv_dilation。默认值：conv_dilation = 1。
+    - **conv_groups** (int，可选) - conv2d Layer的组数，整数。根据Alex Krizhevsky的Deep CNN论文中的分组卷积：当group = 2时，前半部分滤波器仅连接到输入通道的前半部分，而后半部分滤波器仅连接到后半部分输入通道。默认值：conv_groups = 1。
+    - **param_attr** (ParamAttr，可选) - conv2d的weights参数属性。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为param_attr。如果未设置param_attr的初始化，则使用 :math:`Normal（0.0，std）` 初始化参数，并且 ``std`` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}` 。默认值:None
+    - **bias_attr** (ParamAttr | bool | None，可选) - conv2d的bias参数属性。如果设置为False，则不会向输出单元添加bias。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为bias_attr。如果设置bias_attr为None，则将其初始化为零。默认值：None
+    - **act** (str，可选) - conv2d的激活类型，字符串，可以是'relu', 'softmax', 'sigmoid'等激活函数的类型。如果设置为None，则不附加激活。默认值：None。
+    - **use_cudnn** (bool，可选) - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True。
+    - **name** (str|None，可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None
+
+返回： 输入input经过conv2d和pool2d之后输入的结果，数据类型与input相同
+
+返回类型：  Variable
 
 **示例代码**
 
 .. code-block:: python
 
     import paddle.fluid as fluid
+    # 输入 img.shape = [-1, 1, 28, 28]
+    # 使用该接口带如下参数的操作之后，输出conv_pool.shape = [-1, 20, 12, 12]
     img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
     conv_pool = fluid.nets.simple_img_conv_pool(input=img,
                                             filter_size=5,