Update api_cn of develop-branch (#1086)

* fixed one error of api_cn

* fixed some errors of api_cn

* fixed some errors of api_cn

* fixed two errors.

* fixed two errors

* fixed one error.

* fixed one error

* fixed one error.

* fixed two errors.

* fixed one error.

* fixed two errors

* fixed two links

* synchronize api_cn with the api_en of develop.

* updated develop/api_cn

* update the api_cn of develop

* update api_cn of develop

* fixed some errors

* Delete .DS_Store

* Delete .DS_Store

* Delete .DS_Store

* Delete .DS_Store

* Delete .DS_Store

* fixed some wrong links

* fixed two links

* fixed two links and some error.

* fixed some errors.

* fixed two links

doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst

@@ -5,7 +5,7 @@ imdb
 
 IMDB数据集。
 
-本模块的数据集从 http://ai.stanford.edu/%7Eamaas/data/sentiment/IMDB 数据集。这个数据集包含了25000条训练用电影评论数据，25000条测试用评论数据，且这些评论带有明显情感倾向。此外，该模块还提供了用于构建词典的API。
+本模块的数据集来自 https://aistudio.baidu.com/aistudio/datasetDetail/69 。这个数据集包含了25000条训练用电影评论数据，25000条测试用评论数据，且这些评论带有明显情感倾向。此外，该模块还提供了用于构建词典的API。
 
 
 .. py:function:: paddle.dataset.imdb.build_dict(pattern, cutoff)

doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst

@@ -136,10 +136,12 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
 
     def reader(limit=10):
         for i in range(limit):
-            yield [random.random([784]).astype('float32'), random.randint(10)],
+            yield [random.random([784]).astype('float32'), random.random([1]).astype('float32')],
     
     x = fluid.layers.data(name='x', shape=[1, 28, 28])
-    y = fluid.layers.data(name='y', shape=[1], dtype='int64')
+    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+
+    fluid.layers.elementwise_add(x, y)
     
     feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
     place_num = 2
@@ -185,7 +187,7 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
         for i in range(limit):
             yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')),
     
-    place=fluid.CUDAPlace(0)
+    place=fluid.CPUPlace()
     data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32')
     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
     

doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst

@@ -29,6 +29,49 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
     dataset.load_into_memory()
 
 
+.. py:method:: set_queue_num(queue_num)
+
+设置 ``Dataset`` 的输出队列数量，训练进程从队列中获取数据。
+
+
+
+参数:
+    - **queue_num** (int) - dataset输出队列的数量。
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset") 
+    dataset.set_queue_num(12)
+
+.. py:method:: set_fleet_send_batch_size(fleet_send_batch_size)
+
+设置发送batch的大小
+
+参数:
+    - **fleet_send_batch_size** (int) - 设置发送batch的大小。
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
+    dataset.set_fleet_send_batch_size(800)
+
+
+.. py:method:: set_merge_by_lineid(var_list, erase_duplicate_feas=True, min_merge_size=2, keep_unmerged-ins=True)
+
+通过样本id来设置合并，一些线id的实例将会在shuffle之后进行合并，你应该在一个data生成器里面解析样本id。
+
+参数:
+    - **var_list** (list) - 可以被合并的特征列表，其中的每一个元素都是一个 ``Variable`` 。一些类特征我们通常不把它们合并为同样的样本id，所以用户应当指定哪个类特征可以被合并。
+    - **erase_duplicate_feas** (bool) - 合并的时候是否删除重复的特征值。默认为True。
+    - **min_merge_size** (int) - 合并的最小数量。默认为2。
+    - **keep_unmerged_ins** (bool) - 是否保留没有合并的样本，比如有着独特id的样本，或者重复id的数量小于 ``min_merge_size`` 的样本。
+
 .. py:method:: local_shuffle()
 
 局域shuffle。
@@ -89,7 +132,7 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
 
 .. py:method:: get_memory_data_size(fleet=None)
 
-用户可以调用此函数以了解加载进内存后所有workers中的ins数量。
+用户可以调用此函数以了解加载进内存后所有workers中的样本数量。
 
 .. note::
     该函数可能会导致性能不佳，因为它具有barrier。
@@ -114,7 +157,7 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
 
 .. py:method:: get_shuffle_data_size(fleet=None)
 
-获取shuffle数据大小，用户可以调用此函数以了解局域/全局shuffle后所有workers中的ins数量。
+获取shuffle数据大小，用户可以调用此函数以了解局域/全局shuffle后所有workers中的样本数量。
 
 .. note::
     该函数可能会导致局域shuffle性能不佳，因为它具有barrier。但其不影响局域shuffle。

doc/fluid/api_cn/dygraph_cn.rst

@@ -29,6 +29,7 @@ fluid.dygraph
     dygraph_cn/NaturalExpDecay_cn.rst
     dygraph_cn/NCE_cn.rst
     dygraph_cn/NoamDecay_cn.rst
+    dygraph_cn/no_grad_cn.rst
     dygraph_cn/PiecewiseDecay_cn.rst
     dygraph_cn/PolynomialDecay_cn.rst
     dygraph_cn/Pool2D_cn.rst

doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst

@@ -7,7 +7,7 @@ BackwardStrategy
 
 BackwardStrategy是描述反向过程的描述符，现有如下功能:
 
-1. ``sort_sum_gradient`` 按回溯逆序将梯度加和
+ ``sort_sum_gradient`` 按回溯逆序将梯度加和
 
 
 **代码示例**

doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst

@@ -35,19 +35,19 @@ BatchNorm
 
 参数：
     - **name_scope** (str) - 该类的名称
-    - **act** （string，默认None）- 激活函数类型，linear|relu|prelu|...
-    - **is_test** （bool,默认False） - 指示它是否在测试阶段。
-    - **momentum** （float，默认0.9）- 此值用于计算 moving_mean and moving_var. 更新公式为:  :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum` :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum` ， 默认值0.9.
-    - **epsilon** （float，默认1e-05）- 加在分母上为了数值稳定的值。默认值为1e-5。
+    - **act** （str|None）- 激活函数类型，linear|relu|prelu|...
+    - **is_test** （bool） - 指示它是否在测试阶段。默认False。
+    - **momentum** （float）- 此值用于计算 moving_mean and moving_var. 更新公式为:  :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum` :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum` ， 默认值0.9.
+    - **epsilon** （float）- 加在分母上为了数值稳定的值。默认值为1e-5。
     - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None
     - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None
-    - **data_layout** （string,默认NCHW) - NCHW|NHWC。默认NCHW
-    - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出
-    - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean均值。 
+    - **data_layout** （string) - NCHW|NHWC。默认NCHW
+    - **in_place** （bool）- 得出batch norm可复用记忆的输入和输出，默认False。
+    - **moving_mean_name** （string|None）- moving_mean的名称，存储全局Mean均值。默认为None。
     - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局方差。 
     - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值
     - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu。默认为False。
-    - **use_global_stats** （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。
+    - **use_global_stats** （bool） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。默认为False。
     - **trainable_statistics** （bool）- eval模式下是否计算mean均值和var方差。eval模式下，trainable_statistics为True时，由该批数据计算均值和方差。默认为False。
 
 返回： 张量，在输入中运用批正则后的结果

doc/fluid/api_cn/dygraph_cn/FC_cn.rst

@@ -55,11 +55,11 @@ FC
 参数:
   - **name_scope** (str) – 该类的名称
   - **size** (int) – 该层输出单元的数目
-  - **num_flatten_dims** (int, 默认为1) – fc层可以接受一个维度大于2的tensor。此时， 它首先会被扁平化(flattened)为一个二维矩阵。 参数 ``num_flatten_dims`` 决定了输入tensor的flattened方式: 前 ``num_flatten_dims`` (包含边界，从1开始数) 个维度会被扁平化为最终矩阵的第一维 (维度即为矩阵的高), 剩下的 rank(X) - num_flatten_dims 维被扁平化为最终矩阵的第二维 (即矩阵的宽)。 例如， 假设X是一个五维tensor，其形可描述为(2, 3, 4, 5, 6), 且num_flatten_dims = 3。那么扁平化的矩阵形状将会如此： (2 x 3 x 4, 5 x 6) = (24, 30)
+  - **num_flatten_dims** (int) – fc层可以接受一个维度大于2的tensor。此时， 它首先会被扁平化(flattened)为一个二维矩阵。 参数 ``num_flatten_dims`` 决定了输入tensor的flattened方式: 前 ``num_flatten_dims`` (包含边界，从1开始数) 个维度会被扁平化为最终矩阵的第一维 (维度即为矩阵的高), 剩下的 rank(X) - num_flatten_dims 维被扁平化为最终矩阵的第二维 (即矩阵的宽)。 例如， 假设X是一个五维tensor，其形可描述为[2, 3, 4, 5, 6], 且num_flatten_dims = 3。那么扁平化的矩阵形状将会如此： [2 x 3 x 4, 5 x 6] = [24, 30]。默认为1。
   - **param_attr** (ParamAttr|list of ParamAttr|None) – 该层可学习的参数/权的参数属性
   - **bias_attr** (ParamAttr|list of ParamAttr, default None) – 该层bias变量的参数属性。如果值为False， 则bias变量不参与输出单元运算。 如果值为None，bias变量被初始化为0。默认为 None。
   - **act** (str|None) – 应用于输出的Activation（激励函数）
-  - **is_test** (bool) – 表明当前执行是否处于测试阶段的标志
+  - **is_test** (bool) – 表明当前执行是否处于测试阶段的标志。默认为False。
   - **dtype** (str) – 权重的数据类型
 
 

doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst

@@ -9,7 +9,8 @@ GRU单元层。GRU执行步骤基于如下等式：
 
 
 如果origin_mode为True，则该运算公式来自论文
-`Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling  <https://arxiv.org/pdf/1412.3555.pdf>`_ 。
+`Learning Phrase Representations using RNN Encoder-Decoder for Statistical
+Machine Translation  <https://arxiv.org/pdf/1406.1078.pdf>`_ 。
 
 公式如下:
 

doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst

@@ -10,10 +10,10 @@ GroupNorm
 请参考 `Group Normalization <https://arxiv.org/abs/1803.08494>`_ 。
 
 参数：
-    - **name_scope** (str) - 该类名称
-    - **groups** (int) - 从 channel 中分离出来的 group 的数目
-    - **epsilon** (float) - 为防止方差除零，增加一个很小的值
-    - **param_attr** (ParamAttr|None)  - 可学习标度的参数属性 :math:`g`,如果设置为False，则不会向输出单元添加标度。如果设置为0，偏差初始化为1。默认值:None
+    - **name_scope** (str) - 该类名称。
+    - **groups** (int) - 从 channel 中分离出来的 group 的数目。
+    - **epsilon** (float) - 为防止方差除零，增加一个很小的值，默认为1e-05。
+    - **param_attr** (ParamAttr|None)  - 可学习标度的参数属性 :math:`g`,如果设置为False，则不会向输出单元添加标度。如果设置为0，偏差初始化为1。默认值:None。
     - **bias_attr** (ParamAttr|None) - 可学习偏置的参数属性 :math:`b ` , 如果设置为False，则不会向输出单元添加偏置量。如果设置为零，偏置初始化为零。默认值:None。
     - **act** (str) - 将激活应用于输出的 group normalizaiton
     - **data_layout** (string|NCHW) - 只支持NCHW。

doc/fluid/api_cn/dygraph_cn/NCE_cn.rst

@@ -12,17 +12,17 @@ NCE
 该operator默认使用均匀分布进行抽样。
 
 参数:
-    - **name_scope** (str) – 该类的名称
-    - **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’
+    - **name_scope** (str) – 该类的名称。
+    - **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
+    - **seed** (int) – 取样器使用的seed。默认为0。
+    - **is_sparse** (bool) – 标志位，指明是否使用稀疏更新,  :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows。默认为False。
 
 返回： nce loss
 

doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst

@@ -12,8 +12,8 @@ PRelu
 
 
 参数：
-          - **name_scope** （string）- 该类的名称。
-          - **mode** (string) - 权重共享模式。共提供三种激活方式：
+          - **name_scope** （str）- 该类的名称。
+          - **mode** (str) - 权重共享模式。共提供三种激活方式：
 
              .. code-block:: text
 

doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst

@@ -15,7 +15,7 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pooling_type`` ， 池化
 参数：
     - **name_scope** (str) - 该类的名称
     - **pool_size** (int|list|tuple)  - 池化核的大小。如果它是一个元组或列表，它必须包含两个整数值， (pool_size_Height, pool_size_Width)。其他情况下，若为一个整数，则它的平方值将作为池化核大小，比如若pool_size=2, 则池化核大小为2x2，默认值为-1。
-    - **pool_type** (string) - 池化类型，可以是“max”对应max-pooling，“avg”对应average-pooling，默认值为max。
+    - **pool_type** (str) - 池化类型，可以是“max”对应max-pooling，“avg”对应average-pooling，默认值为max。
     - **pool_stride** (int|list|tuple)  - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。否则它是一个整数的平方值。默认值为1。
     - **pool_padding** (int|list|tuple) - 填充大小。如果它是一个元组，它必须包含两个整数值，(pool_padding_on_Height, pool_padding_on_Width)。否则它是一个整数的平方值。默认值为0。
     - **global_pooling** （bool）- 是否用全局池化。如果global_pooling = true， ``ksize`` 和 ``paddings`` 将被忽略。默认值为false
@@ -40,13 +40,13 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pooling_type`` ， 池化
           import numpy
 
           with fluid.dygraph.guard():
-             data = numpy.random.random((3, 32, 32)).astype('float32')
+              data = numpy.random.random((3, 32, 32)).astype('float32')
 
-             pool2d = fluid.dygraph.Pool2D("pool2d",pool_size=2,
+              pool2d = fluid.dygraph.Pool2D("pool2d",pool_size=2,
                             pool_type='max',
                             pool_stride=1,
                             global_pooling=False)
-             pool2d_res = pool2d(data)
+              pool2d_res = pool2d(data)
 
 
 

doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst

+.. _cn_api_fluid_dygraph_no_grad:
+
+no_grad
+-------------------------------
+
+.. py:method:: paddle.fluid.dygraph.no_grad(func)
+
+在动态图模式中，此装饰器将会避免 ``func`` 被装饰时创建反向传播网络。
+
+参数:
+    - **func** (str) – 不需要梯度的函数。
+
+**代码示例**
+
+..  code-block:: python
+
+
+    import numpy as np
+    import paddle.fluid as fluid
+
+    @fluid.dygraph.no_grad
+    def test_layer():
+        with fluid.dygraph.guard():
+            inp = np.ones([3, 32, 32], dtype='float32')
+            t = fluid.dygraph.base.to_variable(inp)
+            fc1 = fluid.FC('fc1', size=4, bias_attr=False, num_flatten_dims=1)
+            fc2 = fluid.FC('fc2', size=4)
+            ret = fc1(t)
+            dy_ret = fc2(ret)
+
+    test_layer()
\ No newline at end of file

doc/fluid/api_cn/fluid_cn.rst

@@ -29,6 +29,7 @@ fluid
     fluid_cn/global_scope_cn.rst
     fluid_cn/gradients_cn.rst
     fluid_cn/in_dygraph_mode_cn.rst
+    fluid_cn/is_compiled_with_cuda_cn.rst
     fluid_cn/LoDTensor_cn.rst
     fluid_cn/LoDTensorArray_cn.rst
     fluid_cn/memory_optimize_cn.rst

doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst

@@ -26,7 +26,7 @@ str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有
 
     import paddle.fluid as fluid
     build_strategy = fluid.BuildStrategy()
-    build_strategy.debug_graphviz_path = ""
+    build_strategy.debug_graphviz_path = "./graph"
 
 
 .. py:attribute:: enable_sequential_execution
@@ -73,23 +73,64 @@ BOOL类型，fuse_relu_depthwise_conv指示是否融合relu和depthwise_conv2d
 
 .. py:attribute:: gradient_scale_strategy
 
-str类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
+``fluid.BuildStrategy.GradientScaleStrategy`` 类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
 
 **代码示例**
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle.fluid.compiler as compiler
+    import numpy
+    import os
+
+    use_cuda = True
+    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+    exe = fluid.Executor(place)
+
+    # NOTE: 如果你使用CPU计算，需要指定CPU_NUM, 否则,fluid
+    # 将使用所有的核的数目作为CPU_NUM,
+    # 这种情况下，输入的batch size应该大于CPU_NUM, 否则, 
+    # 进程将会因为异常而失败。
+    if not use_cuda:
+        os.environ['CPU_NUM'] = str(2)
+        places = fluid.cpu_places()
+    else:
+        places = places = fluid.cuda_places()
+
+    data = fluid.layers.data(name='X', shape=[1], dtype='float32')
+    hidden = fluid.layers.fc(input=data, size=10)
+    loss = fluid.layers.mean(hidden)
+    fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
+
+    fluid.default_startup_program().random_seed=1
+    exe.run(fluid.default_startup_program())
+
     build_strategy = fluid.BuildStrategy()
-    build_strategy.gradient_scale_strategy = True
+    build_strategy.gradient_scale_strategy = \
+         fluid.BuildStrategy.GradientScaleStrategy.Customized
+    compiled_prog = compiler.CompiledProgram(
+         fluid.default_main_program()).with_data_parallel(
+                  loss_name=loss.name, build_strategy=build_strategy,
+                  places = places)
+
+    dev_count =  len(places)
+    x = numpy.random.random(size=(10, 1)).astype('float32')
+    loss_grad = numpy.ones((dev_count)).astype("float32") * 0.01
+    loss_grad_name = loss.name+"@GRAD"
+    loss_data = exe.run(compiled_prog,
+                     feed={"X": x, loss_grad_name : loss_grad},
+                     fetch_list=[loss.name, loss_grad_name])
 
 .. py:attribute:: memory_optimize
 
-bool类型。设为True时可用于减少总内存消耗。为实验性属性，一些变量可能会被优化策略重用/移除。如果你需要在使用该特征时获取某些变量，请把变量的persistable property设为True。默认为False。
+bool类型或者None。设为True时可用于减少总内存消耗。
+默认为None。None表示框架会自动选择使用或者不使用优化策略。当前，None意味着当GC不能使用时，优化策略将被使用。
+True表示可使用，False表示不可使用。默认为None。
 
 .. py:attribute:: reduce_strategy
 
-str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行场所上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行场所，随之将优化后的参数广播给其他执行场所。在一些模型中， ``Reduce`` 策略执行速度更快一些。默认值为 ``AllReduce`` 。
+``fluid.BuildStrategy.ReduceStrategy`` 类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行设备上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行设备，随之将优化后的参数广播给其他执行设备。
+默认值为 ``AllReduce`` 。
 
 **代码示例**
 
@@ -101,7 +142,7 @@ str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce str
 
 .. py:attribute:: remove_unnecessary_lock
 
-BOOL类型。如果设置为True, GPU操作中的一些锁将被释放，ParallelExecutor将运行得更快，默认为 True。
+BOOL类型。如果设置为True, GPU操作中的一些锁将被释放， ``ParallelExecutor`` 将运行得更快，默认为 True。
 
 **代码示例**
 
@@ -114,7 +155,7 @@ BOOL类型。如果设置为True, GPU操作中的一些锁将被释放，Paralle
 
 .. py:attribute:: sync_batch_norm
 
-类型为bool，sync_batch_norm表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。
+类型为bool， ``sync_batch_norm`` 表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。
 
 当前的实现不支持FP16训练和CPU。仅在一台机器上进行同步式批正则，不适用于多台机器。
 

doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst

@@ -137,10 +137,12 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
      
     def reader(limit=10):
         for i in range(limit):
-            yield [random.random([784]).astype('float32'), random.randint(10)],
+            yield [random.random([784]).astype('float32'), random.random([1]).astype('float32')],
      
     x = fluid.layers.data(name='x', shape=[1, 28, 28])
-    y = fluid.layers.data(name='y', shape=[1], dtype='int64')
+    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+
+    fluid.layers.elementwise_add(x, y)
      
     feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
     place_num = 2
@@ -185,7 +187,7 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
         for i in range(limit):
             yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')),
      
-    place=fluid.CUDAPlace(0)
+    place=fluid.CPUPlace()
     data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32')
     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
      

doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst

@@ -33,7 +33,7 @@ ExecutionStrategy
 
 .. py:attribute:: allow_op_delay
 
-这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。但是在一些模型中，allow_op_delay会导致程序中断。默认为False。
+这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。此选项现在已经失效，在下个版本中将会被移除。默认为False。
 
 
 

doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst

@@ -55,7 +55,7 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
 
 
 
-.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → bool
+.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor) → bool
 
 检查LoDTensor的lod值的正确性。
 
@@ -154,7 +154,7 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
             t.set(np.ndarray([5, 30]), fluid.CPUPlace())
             t.set_lod([[0, 2, 5]])
 
-.. py:method::  set_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor, recursive_sequence_lengths: List[List[int]]) → None
+.. py:method::  set_recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor, recursive_sequence_lengths: List[List[int]]) → None
 
 根据递归序列长度recursive_sequence_lengths设置LoDTensor的LoD。
 

doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst

@@ -39,7 +39,7 @@ ParallelExecutor
             test_program = fluid.default_main_program().clone(for_test=True)
             fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
      
-        startup_program.random_seed=1
+
         exe.run(startup_program)
      
         train_exe = fluid.ParallelExecutor(use_cuda=use_cuda,

doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst

@@ -6,10 +6,10 @@ WeightNormParamAttr
 .. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
 
 
-权重归一化。权重归一化是将权重向量的长度与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_ 这篇paper中讨论了权重归一化的实现
+权重归一化。权重归一化是将权重向量的量级与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_ 这篇paper中讨论了权重归一化的实现
 
 参数:
-  - **dim** (list) - 参数的名称。默认None。
+  - **dim** (int) - 归一化的维度。默认None。
   - **name** (str) - 参数的名称。默认None。
   - **initializer** （initializer) - 初始化参数的方法。默认None。
   - **learning_rate** (float) - 学习率。优化时学习速率 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 。默认1.0。

doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst

@@ -25,35 +25,32 @@ default_main_program
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+        import paddle.fluid as fluid
      
-    # Sample Network:
-    data = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+        #示例网络:
+        data = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32')
+        label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    
+        conv1 = fluid.layers.conv2d(data, 4, 5, 1, act=None)
+        bn1 = fluid.layers.batch_norm(conv1, act='relu')
+        pool1 = fluid.layers.pool2d(bn1, 2, 'max', 2)
+        conv2 = fluid.layers.conv2d(pool1, 16, 5, 1, act=None)
+        bn2 = fluid.layers.batch_norm(conv2, act='relu')
+        pool2 = fluid.layers.pool2d(bn2, 2, 'max', 2)
+    
+        fc1 = fluid.layers.fc(pool2, size=50, act='relu')
+        fc2 = fluid.layers.fc(fc1, size=102, act='softmax')
      
-    conv1 = fluid.layers.conv2d(data, 4, 5, 1, act=None)
-    bn1 = fluid.layers.batch_norm(conv1, act='relu')
-    pool1 = fluid.layers.pool2d(bn1, 2, 'max', 2)
-    conv2 = fluid.layers.conv2d(pool1, 16, 5, 1, act=None)
-    bn2 = fluid.layers.batch_norm(conv2, act='relu')
-    pool2 = fluid.layers.pool2d(bn2, 2, 'max', 2)
+        loss = fluid.layers.cross_entropy(input=fc2, label=label)
+        loss = fluid.layers.mean(loss)
+        opt = fluid.optimizer.Momentum(
+            learning_rate=0.1,
+            momentum=0.9,
+            regularization=fluid.regularizer.L2Decay(1e-4))
+        opt.minimize(loss)
      
-    fc1 = fluid.layers.fc(pool2, size=50, act='relu')
-    fc2 = fluid.layers.fc(fc1, size=102, act='softmax')
-     
-    loss = fluid.layers.cross_entropy(input=fc2, label=label)
-    loss = fluid.layers.mean(loss)
-    opt = fluid.optimizer.Momentum(
-        learning_rate=0.1,
-        momentum=0.9,
-        regularization=fluid.regularizer.L2Decay(1e-4))
-    opt.minimize(loss)
-     
-    print(fluid.default_main_program())
-
-
-
-
+        print(fluid.default_main_program().num_blocks)
+        print(fluid.default_main_program().blocks[0].var('image'))
 
 
 

doc/fluid/api_cn/fluid_cn/gradients_cn.rst

@@ -11,7 +11,7 @@ gradients
   - **targets** (Variable|list[Variable]) – 目标变量
   - **inputs** (Variable|list[Variable]) – 输入变量
   - **target_gradients** (Variable|list[Variable]|None) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
-  - **no_grad_sethread** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set
+  - **no_grad_set** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set
 
 
 返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None

doc/fluid/api_cn/fluid_cn/is_compiled_with_cuda_cn.rst

+.. _cn_api_fluid_is_compiled_with_cuda:
+
+is_compiled_with_cuda
+-------------------------------
+
+.. py:function:: paddle.fluid.is_compiled_with_cuda()
+
+检查 ``whl`` 包是否可以被用来在GPU上运行模型
+
+返回：支持gpu则为True,否则为False。
+
+返回类型：out(boolean)
+
+**示例代码**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    support_gpu = fluid.is_compiled_with_cuda()
+
+

doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst

@@ -3,7 +3,7 @@
 memory_optimize
 -------------------------------
 
-.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
+.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True)
 
 历史遗留的内存优化策略，通过在不同operators间重用var内存来减少总内存消耗。
 用一个简单的示例来解释该算法：

doc/fluid/api_cn/fluid_cn/program_guard_cn.rst

@@ -7,9 +7,9 @@ program_guard
 
 
 
-该函数应配合使用python的“with”语句来改变全局主程序(main program)和启动程序(startup program)。
+该函数应配合使用python的 ``with`` 语句来改变全局主程序(main program)和启动程序(startup program)。
 
-“with”语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。
+ ``with`` 语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。
 
 **代码示例**
 

doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst

@@ -14,7 +14,7 @@ BilinearInitializer
     import paddle.fluid as fluid
     factor = 2
     C = 2
-    w_attr = fluid.initializer.ParamAttr(
+    w_attr = fluid.param_attr.ParamAttr(
         learning_rate=0.,
         regularizer=fluid.regularizer.L2Decay(0.),
         initializer=fluid.initializer.Bilinear())

doc/fluid/api_cn/io_cn/PyReader_cn.rst

@@ -26,7 +26,10 @@ PyReader
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
+    import paddle.fluid as fluid
+    import numpy as np
+
     EPOCH_NUM = 3
     ITER_NUM = 5
     BATCH_SIZE = 3
@@ -68,7 +71,10 @@ PyReader
 
 .. code-block:: python
 
-   import paddle.fluid as fluid
+   import paddle
+   import paddle.fluid as fluid
+   import numpy as np
+
    EPOCH_NUM = 3
    ITER_NUM = 5
    BATCH_SIZE = 10
@@ -137,7 +143,10 @@ PyReader
 
 .. code-block:: python
 
+  import paddle
   import paddle.fluid as fluid
+  import numpy as np
+
   BATCH_SIZE = 10
      
   def generator():
@@ -168,7 +177,10 @@ PyReader
 
 .. code-block:: python
 
+            import paddle
             import paddle.fluid as fluid
+            import numpy as np
+
             BATCH_SIZE = 10
      
             def generator():
@@ -211,7 +223,9 @@ PyReader
 
 .. code-block:: python
      
-            import paddle.fluid as fluid
+            import paddle.fluid as fluid
+            import numpy as np
+
             EPOCH_NUM = 3
             ITER_NUM = 15
             BATCH_SIZE = 3
@@ -258,7 +272,10 @@ PyReader
 
 .. code-block:: python
             
+            import paddle
             import paddle.fluid as fluid
+            import numpy as np
+
             EPOCH_NUM = 3
             ITER_NUM = 15
             BATCH_SIZE = 3
@@ -305,7 +322,9 @@ PyReader
 
 .. code-block:: python
 
-            import paddle.fluid as fluid
+            import paddle.fluid as fluid
+            import numpy as np
+
             EPOCH_NUM = 3
             ITER_NUM = 15
             BATCH_SIZE = 3

doc/fluid/api_cn/layers_cn.rst

@@ -41,6 +41,7 @@ fluid.layers
     layers_cn/brelu_cn.rst
     layers_cn/cast_cn.rst
     layers_cn/ceil_cn.rst
+    layers_cn/center_loss_cn.rst
     layers_cn/chunk_eval_cn.rst
     layers_cn/clip_by_norm_cn.rst
     layers_cn/clip_cn.rst
@@ -141,6 +142,7 @@ fluid.layers
     layers_cn/linear_lr_warmup_cn.rst
     layers_cn/linspace_cn.rst
     layers_cn/load_cn.rst
+    layers_cn/lod_append_cn.rst
     layers_cn/lod_reset_cn.rst
     layers_cn/log_cn.rst
     layers_cn/log_loss_cn.rst
@@ -239,6 +241,7 @@ fluid.layers
     layers_cn/sequence_softmax_cn.rst
     layers_cn/sequence_unpad_cn.rst
     layers_cn/shape_cn.rst
+    layers_cn/shard_index_cn.rst
     layers_cn/shuffle_channel_cn.rst
     layers_cn/shuffle_cn.rst
     layers_cn/sigmoid_cn.rst
@@ -247,6 +250,7 @@ fluid.layers
     layers_cn/sign_cn.rst
     layers_cn/similarity_focus_cn.rst
     layers_cn/sin_cn.rst
+    layers_cn/size_cn.rst
     layers_cn/slice_cn.rst
     layers_cn/smooth_l1_cn.rst
     layers_cn/soft_relu_cn.rst
@@ -280,10 +284,14 @@ fluid.layers
     layers_cn/topk_cn.rst
     layers_cn/transpose_cn.rst
     layers_cn/tree_conv_cn.rst
+    layers_cn/unfold_cn.rst
     layers_cn/uniform_random_batch_size_like_cn.rst
     layers_cn/uniform_random_cn.rst
+    layers_cn/unique_cn.rst
+    layers_cn/unique_with_counts_cn.rst
     layers_cn/unsqueeze_cn.rst
     layers_cn/unstack_cn.rst
+    layers_cn/var_conv_2d_cn.rst
     layers_cn/warpctc_cn.rst
     layers_cn/where_cn.rst
     layers_cn/While_cn.rst

doc/fluid/api_cn/layers_cn/auc_cn.rst

@@ -25,7 +25,8 @@ auc
     - **topk** (int) - 只有预测输出的topk数才被用于auc
     - **slide_steps** - 计算批auc时，不仅用当前步也用先前步。slide_steps=1，表示用当前步；slide_steps = 3表示用当前步和前两步；slide_steps = 0，则用所有步
 
-返回：代表当前AUC的scalar
+返回：代表当前AUC的一个元组
+返回的元组为auc_out, batch_auc_out, [batch_stat_pos, batch_stat_neg, stat_pos, stat_neg]。
 
 返回类型：变量（Variable）
 

doc/fluid/api_cn/layers_cn/batch_norm_cn.rst

@@ -33,20 +33,20 @@ batch_norm
 
 
 参数：
-    - **input** (Variable) - 输入变量的排序，可以为 2, 3, 4, 5
+    - **input** (Variable) - 输入变量的排序，可以为 2, 3, 4, 5。
     - **act** （string，默认None）- 激活函数类型，linear|relu|prelu|...
     - **is_test** （bool,默认False） - 指示它是否在测试阶段。
-    - **momentum** （float，默认0.9）- 此值用于计算 moving_mean 和 moving_var。更新公式为:  :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)` ， :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)` ， 默认值0.9.
+    - **momentum** （float，默认0.9）- 此值用于计算 moving_mean 和 moving_var。更新公式为:  :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)` ， :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)` ， 默认值0.9。
     - **epsilon** （float，默认1e-05）- 加在分母上为了数值稳定的值。默认值为1e-5。
-    - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None
-    - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None
-    - **data_layout** （string,默认NCHW) - NCHW|NHWC
-    - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出
-    - **name** （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名
-    - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, ``batch_norm`` 将随机命名全局平均值；否则， ``batch_norm`` 将命名全局平均值为 ``moving_mean_name``   
-    - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None, ``batch_norm`` 将随机命名全局方差；否则， ``batch_norm`` 将命名全局方差为 ``moving_variance_name`` 
-    - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值
-    - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu
+    - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None。
+    - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None。
+    - **data_layout** （string,默认NCHW) - NCHW|NHWC。
+    - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出。
+    - **name** （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名。
+    - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, ``batch_norm`` 将随机命名全局平均值；否则， ``batch_norm`` 将命名全局平均值为 ``moving_mean_name`` 。
+    - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None, ``batch_norm`` 将随机命名全局方差；否则， ``batch_norm`` 将命名全局方差为 ``moving_variance_name`` 。
+    - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值。
+    - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu。
     - **use_global_stats** （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。
 
 返回： 张量，在输入中运用批正则后的结果

doc/fluid/api_cn/layers_cn/center_loss_cn.rst

+.. _cn_api_fluid_layers_center_loss:
+
+center_loss
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.center_loss(input, label, num_classes, alpha, param_attr, update_center=True)
+
+center_loss层
+该层接收一个来自于最后一个隐藏层的输出和目标标签作为输入，返回损失值。
+对于输入，\(X\)和标签\(Y\)，计算公式为：
+
+    .. math::
+
+        out = \frac{1}{2}(X - Y)^2
+
+
+
+参数:
+
+    - **input** (Variable) - 形为[N x M]的2维张量
+    - **label** (Variable) - groud truth,一个形为[N x 1]的2维张量，N表示batch size
+    - **num_class** (int) - 表示类别的数
+    - **alpha** (float|Variable) - 学习率
+    - **param_attr** (ParamAttr) - 参数初始化
+    - **update_center** (bool) - 是否更新损失值
+
+返回：形为[N x 1]的2维张量。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+        import paddle.fluid as fluid
+        
+        input = fluid.layers.data(name='x',shape=[20,30],dtype='float32')
+        label = fluid.layers.data(name='y',shape=[20,1],dtype='int64')
+        num_classes = 1000
+        alpha = 0.01
+        param_attr = fluid.initializer.Xavier(uniform=False)
+        center_loss=fluid.layers.center_loss(input=input,
+            label=label,
+            num_classes=1000,
+            alpha=alpha,
+            param_attr=fluid.initializer.Xavier(uniform=False),
+            update_center=True)
+
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst

@@ -3,7 +3,7 @@
 chunk_eval
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.chunk_eval(input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None)
+.. py:function:: paddle.fluid.layers.chunk_eval(input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None, sqe_length=None)
 
 块估计（Chunk Evaluator）
 
@@ -67,6 +67,7 @@ num_tag_type是标注规则中的标签类型数，num_chunk_type是块类型数
     - **chunk_scheme** (str) - 标注规则，表示如何解码块。必须数IOB，IOE，IOBES或者plain。详情见描述
     - **num_chunk_types** (int) - 块类型数。详情见描述
     - **excluded_chunk_types** (list) - 列表包含块类型id，表示不在计数内的块类型。详情见描述
+    - **seq_length** (Variable) - 当输入和标签是张量时，指定序列长度的一个1维张量
 
 返回：元组（tuple），包含precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks
 

doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst

@@ -53,7 +53,10 @@ conv2d_transpose
         & H_{out}\in[H'_{out},H'_{out} + strides[0])\\
         & W_{out}\in[W'_{out},W'_{out} + strides[1])\\
 
-
+注意：
+如果 ``output_size`` 为None，则 :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;
+否则， 输出size的 :math:`H_{out}` 应当介于 :math:`H^\prime_{out}`
+和 :math:`H^\prime_{out} + strides[0]` 之间, 并且输出size的 :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[1]` 之间, ``conv2d_transpose`` 可以自动计算kernel大小。
 
 参数:
   - **input** （Variable）- 输入张量，格式为[N, C, H, W]

doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst

@@ -32,6 +32,9 @@ create_py_reader_by_data
         predict = fluid.layers.fc(input=img, size=10, act='softmax')
         loss = fluid.layers.cross_entropy(input=predict, label=label)
         return fluid.layers.mean(loss)
+
+    MEMORY_OPT = False
+    USE_CUDA = False
     
     image = fluid.layers.data(name='image', shape=[1, 28, 28], dtype='float32')
     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
@@ -42,14 +45,23 @@ create_py_reader_by_data
     img, label = fluid.layers.read_file(reader)
     loss = network(img, label) # 一些网络定义
 
-    fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
+    place = fluid.CUDAPlace(0) if USE_CUDA else fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+
+    build_strategy = fluid.BuildStrategy()
+    build_strategy.memory_optimize = True if MEMORY_OPT else False
+    compiled_prog = compiler.CompiledProgram(
+        fluid.default_main_program()).with_data_parallel(
+            loss_name=loss.name,
+            build_strategy=build_strategy,
+            exec_strategy=exec_strategy)
 
-    exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
-    for epoch_id in range(10):
+    for epoch_id in range(2):
         reader.start()
         try:
             while True:
-                exe.run(fetch_list=[loss.name])
+                exe.run(compiled_prog, fetch_list=[loss.name])
         except fluid.core.EOFException:
             reader.reset()
 

doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst

@@ -9,10 +9,10 @@ density_prior_box
 **Density Prior Box Operator**
 
 为SSD算法(Single Shot MultiBox Detector)生成density prior box。
-每个input的位置产生N个prior box，其中，N通过densities, fixed_sizes and fixed_ratios
-的量来决定。在每个input位置附近的box center格点，通过此op生成。格点坐标由densities决定，
-density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed_sizes
-和densities相等。对于densities中的densities_i：
+每个 ``input`` 的位置产生N个prior box，其中，N通过 ``densities`` , ``fixed_sizes`` 和 ``fixed_ratios``
+的量来决定。在每个input位置附近的box center格点，通过此op生成。格点坐标由 ``densities`` 决定，
+density prior box的量由 ``fixed_sizes`` 和 ``fixed_ratios`` 决定。显然地，``fixed_sizes``
+和 ``densities`` 相等。对于 ``densities`` 中的densities_i：
 
 .. math::
 
@@ -27,7 +27,7 @@ density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed
   - **fixed_ratios** (list|tuple|None) - 被生成的density prior boxes的固定长度，如果该属性未被设置，同时 :attr:`densities` 和 :attr:`fix_sizes` 被设置，则 :attr:`aspect_ratios` 被用于生成 density prior boxes
   - **variance** (list|tuple) - 将被用于density prior boxes编码的方差，默认值为:[0.1, 0.1, 0.2, 0.2]
   - **clip(bool)** - 是否clip超出范围的box。默认值：False
-  - **step** (list|turple) - Prior boxes在宽度和高度的步长，如果step[0] == 0.0/step[1] == 0.0, input的the density prior boxes的高度/宽度的步长将被自动计算。默认值：Default: [0., 0.]
+  - **step** (list|tuple) - Prior boxes在宽度和高度的步长，如果step[0] == 0.0/step[1] == 0.0, input的the density prior boxes的高度/宽度的步长将被自动计算。默认值：Default: [0., 0.]
   - **offset** (float) - Prior boxes中心补偿值，默认为：0.5
   - **flatten_to_2d** (bool) - 是否将output prior boxes和方差 ``flatten`` 至2维形状，第二个dim为4。默认值：False
   - **name(str)** - density prior box op的名字，默认值: None

doc/fluid/api_cn/layers_cn/diag_cn.rst

@@ -21,8 +21,10 @@ diag
         #  [3, 0, 0]
         #  [0, 4, 0]
         #  [0, 0, 5]
+
         import paddle.fluid as fluid
-        data = fluid.layers.diag(np.arange(3, 6))
+        import numpy as np
+        data = fluid.layers.diag(np.arange(3, 6, dtype='int32'))
 
 
 

doc/fluid/api_cn/layers_cn/double_buffer_cn.rst

@@ -24,6 +24,7 @@ double_buffer
   import paddle.fluid as fluid
   reader = fluid.layers.open_files(filenames=['mnist.recordio'],
            shapes=[[-1, 784], [-1, 1]],
+           lod_levels=[0, 0],
            dtypes=['float32', 'int64'])
   reader = fluid.layers.double_buffer(reader)
   img, label = fluid.layers.read_file(reader)

doc/fluid/api_cn/layers_cn/edit_distance_cn.rst

@@ -4,7 +4,7 @@
 edit_distance
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.edit_distance(input,label,normalized=True,ignored_tokens=None)
+.. py:function:: paddle.fluid.layers.edit_distance(input,label,normalized=True,ignored_tokens=None, input_length=None, label_length=None）
 
 编辑距离算子
 
@@ -14,53 +14,37 @@ edit_distance
 
 “kitten”->“sitten”->“sittn”->“sitting”
 
-输入为LoDTensor,包含假设字符串（带有表示批尺寸的总数）和分离信息（具体为LoD信息）。并且批尺寸大小的参照字符串和输入LoDTensor的顺序保持一致。
+输入为LoDTensor/Tensor,包含假设字符串（带有表示批尺寸的总数）和分离信息（具体为LoD信息或者 ``input_length`` ）。并且批尺寸大小的参照字符串和输入LoDTensor的顺序保持一致。
 
 输出包含批尺寸大小的结果，代表一对字符串中每个字符串的编辑距离。如果Attr(normalized)为真，编辑距离则处以参照字符串的长度。
 
 参数：
-    - **input** (Variable)-假设字符串的索引
-    - **label** (Variable)-参照字符串的索引
+    - **input** (Variable)-假设字符串的索引，为两列并且类型为int64
+    - **label** (Variable)-参照字符串的索引，为两列并且类型为int64
     - **normalized** (bool,默认为True)-表示是否用参照字符串的长度进行归一化
     - **ignored_tokens** (list<int>,默认为None)-计算编辑距离前需要移除的token
     - **name** (str)-该层名称，可选
 
-返回：[batch_size,1]中序列到序列到编辑距离
+返回：形为[batch_size,1]的编辑距离。
+sequence_num(Variable):形为[ ]的序列数
 
-返回类型：变量
-
-**代码示例**：
+**代码示例**
 
 .. code-block:: python
 
     import paddle.fluid as fluid
-    x = fluid.layers.data(name='x', shape=[1], dtype='int64')
-    y = fluid.layers.data(name='y', shape=[1], dtype='int64')
-    cost, _ = fluid.layers.edit_distance(input=x,label=y)
-
-    cpu = fluid.core.CPUPlace()
-    exe = fluid.Executor(cpu)
-    exe.run(fluid.default_startup_program())
-
-    import numpy
-    x_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
-    y_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
-    
-    print(x_)
-    print(y_)
-    
-    x = fluid.create_lod_tensor(x_, [[2]], cpu)
-    y = fluid.create_lod_tensor(y_, [[2]], cpu)
-    
-    outs = exe.run(feed={'x':x, 'y':y}, fetch_list=[cost.name])
-    
-    print(outs)
-
-
-
-
-
-
-
-
 
+    # 使用 LoDTensor
+    x_lod = fluid.layers.data(name='x_lod', shape=[1], dtype='int64', lod_level=1)
+    y_lod = fluid.layers.data(name='y_lod', shape=[1], dtype='int64', lod_level=1)
+    distance_lod, seq_num_lod = fluid.layers.edit_distance(input=x_lod, label=y_lod)
+
+    # 使用 Tensor
+    x_seq_len = 5
+    y_seq_len = 6
+    x_pad = fluid.layers.data(name='x_pad', shape=[x_seq_len], dtype='int64')
+    y_pad = fluid.layers.data(name='y_pad', shape=[y_seq_len], dtype='int64')
+    x_len = fluid.layers.data(name='x_len', shape=[], dtype='int64')
+    y_len = fluid.layers.data(name='y_len', shape=[], dtype='int64')
+    distance_pad, seq_num_pad = fluid.layers.edit_distance(
+                    input=x_pad, label=y_pad, input_length=x_len, label_length=y_len)
\ No newline at end of file

doc/fluid/api_cn/layers_cn/embedding_cn.rst

@@ -11,7 +11,7 @@ embedding
 所有的输入变量都作为局部变量传入LayerHelper构造器
 
 参数：
-    - **input** (Variable)-包含IDs的张量
+    - **input** (Variable)-包含IDs信息的int64的张量变量。
     - **size** (tuple|list)-查找表参数的维度。应当有两个参数，一个代表嵌入矩阵字典的大小，一个代表每个嵌入向量的大小。
     - **is_sparse** (bool)-代表是否用稀疏更新的标志
     - **is_distributed** (bool)-是否从远程参数服务端运行查找表

doc/fluid/api_cn/layers_cn/expand_cn.rst

@@ -38,7 +38,7 @@ expand运算会按给定的次数对输入各维度进行复制（tile）运算
 ..  code-block:: python
 
         import paddle.fluid as fluid
-        x = fluid.layers.data(name='x', shape=[10], dtype='float32')
+        x = fluid.layers.fill_constant(shape=[2, 3, 1], dtype='int32', value=0)
         out = fluid.layers.expand(x=x, expand_times=[1, 2, 2])
 
 

doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst

@@ -49,8 +49,8 @@ RpnRois 是RPN的输出box， 并由 ``GenerateProposals`` 来进一步处理,
                    append_batch_size=False, dtype='float32')
     im_info = fluid.layers.data(name='im_info', shape=[10, 3],
                    append_batch_size=False, dtype='float32')
-    rois, labels_int32, bbox_targets, bbox_inside_weights,
-    bbox_outside_weights = fluid.layers.generate_proposal_labels(
+    rois, labels, bbox, inside_weights,
+    outside_weights = fluid.layers.generate_proposal_labels(
                    rpn_rois, gt_classes, is_crowd, gt_boxes, im_info,
                    class_nums=10)
 

doc/fluid/api_cn/layers_cn/greater_equal_cn.rst

@@ -21,6 +21,8 @@ greater_equal
 .. code-block:: python
 
      import paddle.fluid as fluid
+     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+     limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64')
      out = fluid.layers.greater_equal(x=label, y=limit)
 
 

doc/fluid/api_cn/layers_cn/greater_than_cn.rst

@@ -21,6 +21,8 @@ greater_than
 .. code-block:: python
 
      import paddle.fluid as fluid
+     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+     limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64')
      out = fluid.layers.greater_than(x=label, y=limit)
 
 

doc/fluid/api_cn/layers_cn/hash_cn.rst

@@ -16,10 +16,9 @@ hash
   给出：
 
     # shape [2, 2]
-    input.data = [
+    input.data = 
         [[1, 2],
-        [3, 4]],
-    ]
+        [3, 4]]
 
     input.lod = [[0, 2]]
 
@@ -46,12 +45,12 @@ hash
     output.lod = [[0, 2]]
 
 参数：
-  - **input** (Variable) - 输入变量是一个 one-hot 词。输入变量的维数必须是2。
+  - **input** (Variable) - 输入变量是一个 one-hot 词。输入变量的维数必须是2。支持Tensor与LodTensor。
   - **hash_size** (int) - 哈希算法的空间大小。输出值将保持在 :math:`[0, hash\_size - 1]` 范围内。
   - **num_hash** (int) - 哈希次数，默认为1。
   - **name** (str, default None) - 该层的名称
 
-返回：哈希的结果变量，是一个lodtensor。
+返回：哈希的结果变量，与输入变量类型相同。
 
 返回类型： Variable
 
@@ -60,24 +59,16 @@ hash
 .. code-block:: python
 
     import paddle.fluid as fluid
-    import paddle.fluid.layers as layers
-    import numpy as np
-
-    titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=1)
-    hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=1, hash_size=1000)
 
-    place = fluid.core.CPUPlace()
-    exece = fluid.Executor(place)
-    exece.run(fluid.default_startup_program())
-
-    # 初始化Tensor
-    tensor = fluid.core.LoDTensor()
-    tensor.set(np.random.randint(0, 10, (3, 1)).astype("int32"), place)
-    # 设置LoD
-    tensor.set_recursive_sequence_lengths([[1, 1, 1]])
-
-    out = exece.run(feed={'titles': tensor}, fetch_list=[hash_r], return_numpy=False)
+    # titles形为[batch, 1]
+    titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=0)
+    # hash_r形为[batch, 2]
+    hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=2, hash_size=1000)
 
+    # titles形为[batch, 1]并且拥有lod信息
+    titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=1)
+    # hash_r形为[batch, 2]并且从titles继承lod信息
+    hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=2, hash_size=1000)
 
 
 

doc/fluid/api_cn/layers_cn/isfinite_cn.rst

@@ -22,7 +22,7 @@ isfinite
     var = fluid.layers.data(name="data",
                             shape=(4, 6),
                             dtype="float32")
-    out = fluid.layers.isfinite(v)
+    out = fluid.layers.isfinite(var)
 
 
 

doc/fluid/api_cn/layers_cn/less_equal_cn.rst

@@ -21,6 +21,8 @@ less_equal
 .. code-block:: python
 
      import paddle.fluid as fluid
+     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+     limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64')
      out = fluid.layers.less_equal(x=label, y=limit)
 
 

doc/fluid/api_cn/layers_cn/lod_append_cn.rst

+.. _cn_api_fluid_layers_lod_append:
+
+lod_append
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.lod_append(x, level)
+
+给 ``x`` 的LoD添加 ``level`` 。
+
+简单示例：
+
+.. code-block:: python
+
+    give a 1-level LodTensor x:
+        x.lod = [[2, 3, 1]]
+        x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+        x.dims = [6, 1]
+
+    level:[1, 1, 1, 1, 1, 1]
+
+    Then we get a 2-level LodTensor:
+        x.lod = [[2, 3, 1], [1, 1, 1, 1, 1, 1]
+        x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+        x.dims = [6, 1]
+
+参数：
+    - **x** (Variable)-输入变量，可以是LoDTensor或tensor。
+    - **level** (list|tuple|Variable)-预添加到x的LoD里的LoD level。
+
+返回：一个有着新的LoD level的输出变量
+
+返回类型：Variable
+
+Raise: ``ValueError`` - 如果y为None或者level不可迭代。
+
+**代码示例：**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    x = fluid.layers.data(name='x', shape=[6, 10], lod_level=1)
+    out = fluid.layers.lod_append(x, [1,1,1,1,1,1])
+
+
+
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/lod_reset_cn.rst

@@ -6,7 +6,7 @@ lod_reset
 .. py:function:: paddle.fluid.layers.lod_reset(x, y=None, target_lod=None)
 
 
-设定x的LoD为y或者target_lod。如果提供y，首先将y.lod指定为目标LoD,否则y.data将指定为目标LoD。如果未提供y，目标LoD则指定为target_lod。如果目标LoD指定为Y.data或target_lod，只提供一层LoD。
+设定 ``x`` 的LoD为 ``y`` 或者 ``target_lod`` 。如果提供 ``y`` ，首先将y.lod指定为目标LoD,否则y.data将指定为目标LoD。如果未提供y，目标LoD则指定为 ``target_lod`` 。如果目标LoD指定为y.data或 ``target_lod`` ，只提供一层LoD。
 
 ::
 
@@ -59,15 +59,15 @@ lod_reset
         out.dims = [6, 1]
 
 参数：
-    - **x** (Variable)-输入变量，可以为Tensor或者LodTensor
-    - **y** (Variable|None)-若提供，输出的LoD则衍生自y
-    - **target_lod** (list|tuple|None)-一层LoD，y未提供时作为目标LoD
+    - **x** (Variable)-输入变量，可以为Tensor或者LoDTensor
+    - **y** (Variable|None)-若提供，输出的LoD则衍生自 ``y``
+    - **target_lod** (list|tuple|None)-一层LoD，``y`` 未提供时作为目标LoD
 
 返回：输出变量，该层指定为LoD
 
 返回类型：变量
 
-抛出异常：``TypeError`` - 如果y和target_lod都为空
+抛出异常：``TypeError`` - 如果 ``y`` 和 ``target_lod`` 都为空
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/logical_and_cn.rst

@@ -7,7 +7,7 @@ logical_and
 
 logical_and算子
 
-它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为：
+它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。``X``、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为：
 
 .. math::
        Out = X \&\& Y
@@ -29,9 +29,9 @@ logical_and算子
 
     import paddle.fluid as fluid
     left = fluid.layers.data(
-        name='left', shape=[1], dtype='int32')
+        name='left', shape=[1], dtype='bool')
     right = fluid.layers.data(
-        name='right', shape=[1], dtype='int32')
+        name='right', shape=[1], dtype='bool')
     result = fluid.layers.logical_and(x=left, y=right)
 
 

doc/fluid/api_cn/layers_cn/logical_not_cn.rst

@@ -7,7 +7,7 @@ logical_not
 
 logical_not算子
 
-它在X上以元素方式操作，并返回Out。X和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为：
+它在 ``X`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为：
 
 .. math::
         Out = !X
@@ -28,7 +28,7 @@ logical_not算子
 
     import paddle.fluid as fluid
     left = fluid.layers.data(
-        name='left', shape=[1], dtype='int32')
+        name='left', shape=[1], dtype='bool')
     result = fluid.layers.logical_not(x=left)
 
 

doc/fluid/api_cn/layers_cn/logical_or_cn.rst

@@ -7,7 +7,7 @@ logical_or
 
 logical_or算子
 
-它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为：
+它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为：
 
 .. math::
         Out = X || Y
@@ -31,9 +31,9 @@ logical_or算子
 
     import paddle.fluid as fluid
     left = fluid.layers.data(
-        name='left', shape=[1], dtype='int32')
+        name='left', shape=[1], dtype='bool')
     right = fluid.layers.data(
-        name='right', shape=[1], dtype='int32')
+        name='right', shape=[1], dtype='bool')
     result = fluid.layers.logical_or(x=left, y=right)
 
 

doc/fluid/api_cn/layers_cn/logical_xor_cn.rst

@@ -7,7 +7,7 @@ logical_xor
 
 logical_xor算子
 
-它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为：
+它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为：
 
 .. math::
         Out = (X || Y) \&\& !(X \&\& Y)
@@ -30,9 +30,9 @@ logical_xor算子
 
     import paddle.fluid as fluid
     left = fluid.layers.data(
-        name='left', shape=[1], dtype='int32')
+        name='left', shape=[1], dtype='bool')
     right = fluid.layers.data(
-        name='right', shape=[1], dtype='int32')
+        name='right', shape=[1], dtype='bool')
     result = fluid.layers.logical_xor(x=left, y=right)
 
 

doc/fluid/api_cn/layers_cn/lstm_cn.rst

@@ -46,9 +46,9 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。
 
 返回：   三个张量， rnn_out, last_h, last_c:
 
-- rnn_out为LSTM hidden的输出结果。形为(seq_len x batch_size x hidden_size)如果is_bidirec设置为True,则形为(seq_len x batch_sze hidden_size * 2)
-- last_h(Tensor):  LSTM最后一步的隐藏状态，形状为(num_layers x batch_size x hidden_size)；如果is_bidirec设置为True，形状为(num_layers*2 x batch_size x hidden_size)
-- last_c(Tensor)： LSTM最后一步的cell状态，形状为(num_layers x batch_size x hidden_size)；如果is_bidirec设置为True，形状为(num_layers*2 x batch_size x hidden_size)
+- rnn_out为LSTM hidden的输出结果。形为(seq_len x batch_size x hidden_size)如果 ``is_bidirec`` 设置为True,则形为(seq_len x batch_sze hidden_size * 2)
+- last_h(Tensor):  LSTM最后一步的隐藏状态，形状为(num_layers x batch_size x hidden_size)；如果 ``is_bidirec`` 设置为True，形状为(num_layers*2 x batch_size x hidden_size)
+- last_c(Tensor)： LSTM最后一步的cell状态，形状为(num_layers x batch_size x hidden_size)；如果 ``is_bidirec`` 设置为True，形状为(num_layers*2 x batch_size x hidden_size)
 
 返回类型:   rnn_out(Tensor),last_h(Tensor),last_c(Tensor)
 
@@ -57,6 +57,8 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。
 .. code-block:: python
 
   import paddle.fluid as fluid
+  import paddle.fluid.layers as layers
+
   emb_dim = 256
   vocab_size = 10000
   data = fluid.layers.data(name='x', shape=[-1, 100, 1],

doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst

@@ -36,8 +36,8 @@ lstm单元的输入包括 :math:`x_{t}` ， :math:`h_{t-1}` 和 :math:`c_{t-1}`
     - **hidden_t_prev** (Variable) - lstm单元的隐藏状态值，二维张量，shape为 M x S，M是批尺寸，N是lstm单元的大小
     - **cell_t_prev** (Variable) - lstm单元的cell值，二维张量，shape为 M x S ，M是批尺寸，N是lstm单元的大小
     - **forget_bias** (Variable) - lstm单元的遗忘bias
-    - **param_attr** (ParamAttr|None) - 可学习hidden-hidden权重的擦参数属性。如果设为None或者ParamAttr的一个属性，lstm_unit创建ParamAttr为param_attr。如果param_attr的初始化函数未设置，参数初始化为Xavier。默认：None
-    - **bias_attr** (ParamAttr|None) - 可学习bias权重的bias属性。如果设为False，输出单元中则不添加bias。如果设为None或者ParamAttr的一个属性，lstm_unit创建ParamAttr为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认：None
+    - **param_attr** (ParamAttr|None) - 可学习hidden-hidden权重的擦参数属性。如果设为None或者 ``ParamAttr`` 的一个属性，lstm_unit创建 ``ParamAttr`` 为param_attr。如果param_attr的初始化函数未设置，参数初始化为Xavier。默认：None
+    - **bias_attr** (ParamAttr|None) - 可学习bias权重的bias属性。如果设为False，输出单元中则不添加bias。如果设为None或者 ``ParamAttr`` 的一个属性，lstm_unit创建 ``ParamAttr`` 为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认：None
     - **name** (str|None) - 该层名称（可选）。若设为None，则自动为该层命名
 
 返回：lstm单元的hidden(隐藏状态)值和cell值

doc/fluid/api_cn/layers_cn/matmul_cn.rst

@@ -10,11 +10,11 @@ matmul
 对两个张量进行矩阵相乘
 
 当前输入的张量可以为任意阶，但当任意一个输入的阶数大于3时，两个输入的阶必须相等。
-实际的操作取决于x,y的维度和 ``transpose_x`` , ``transpose_y`` 的标记值。具体如下：
+实际的操作取决于 ``x`` , ``y`` 的维度和 ``transpose_x`` , ``transpose_y`` 的标记值。具体如下：
 
-- 如果transpose值为真，则对应 ``tensor`` 的最后两维将被转置。如：x是一个shape=[D]的一阶张量，那么x在非转置形式中为[1,D]，在转置形式中为[D,1],而y则相反，在非转置形式中作为[D,1]，在转置形式中作为[1,D]。
+- 如果transpose值为真，则对应 ``tensor`` 的最后两维将被转置。如：``x``是一个shape=[D]的一阶张量，那么 ``x`` 在非转置形式中为[1,D]，在转置形式中为[D,1],而 ``y`` 则相反，在非转置形式中作为[D,1]，在转置形式中作为[1,D]。
 
-- 转置后，这两个`tensors`将为 2-D 或 n-D ,并依据下列规则进行矩阵相乘：
+- 转置后，这两个tensors将为 2-D 或 n-D ,并依据下列规则进行矩阵相乘：
   - 如果两个都是2-D，则同普通矩阵一样进行矩阵相乘
   - 如果任意一个是n-D，则将其视为驻留在最后两个维度的矩阵堆栈，并在两个张量上应用支持广播的批处理矩阵乘法。
 
@@ -29,7 +29,7 @@ matmul
     - **alpha** (float)-输出比例。默认为1.0
     - **name** (str|None)-该层名称（可选）。如果设置为空，则自动为该层命名
 
-返回：张量乘积变量
+返回：Tensor或者LoDTensor变量
 
 返回类型：变量（Variable）
 

doc/fluid/api_cn/layers_cn/not_equal_cn.rst

@@ -21,6 +21,9 @@ not_equal
 .. code-block:: python
 
      import paddle.fluid as fluid
+
+     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+     limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64')
      out = fluid.layers.not_equal(x=label, y=limit)
 
 

doc/fluid/api_cn/layers_cn/one_hot_cn.rst

@@ -3,13 +3,14 @@
 one_hot
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.one_hot(input, depth)
+.. py:function:: paddle.fluid.layers.one_hot(input, depth, allow_out_of_range=False)
 
 该层创建输入指数的one-hot表示
 
 参数：
-    - **input** (Variable)-输入指数，最后维度必须为1
-    - **depth** (scalar)-整数，定义one-hot维度的深度
+    - **input** (Variable) - 输入指数，最后维度必须为1
+    - **depth** (scalar) - 整数，定义one-hot维度的深度
+    - **allow_out_of_range** - bool值，指明输入的索引是否可以超出[0, depth]。当输入索引超出范围时，如果 ``allow_out_of_range`` 为False，则会引发异常，如果设置为True，超出的部分会以0填充。
 
 返回：输入的one-hot表示
 

doc/fluid/api_cn/layers_cn/ones_like_cn.rst

+.. _cn_api_fluid_layers_ones_like:
+
+ones_like
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.ones_like(x, out=None)
+
+ones_like
+
+该功能创建一个形状与类型与x相似的张量，初始值为1。
+
+
+参数：
+    - **x** (Variable) - 指定形状与数据类型的输入张量
+    - **out** (Variable)-输出张量
+
+返回：输出张量
+
+返回类型：变量（Variable）
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+
+    x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
+    data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0]
+
+
+

doc/fluid/api_cn/layers_cn/pad_cn.rst

@@ -6,7 +6,7 @@ pad
 .. py:function:: paddle.fluid.layers.pad(x, paddings, pad_value=0.0, name=None)
 
 在张量上加上一个由 ``pad_value`` 给出的常数值，填充宽度由 ``paddings`` 指定。
-其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[i+1]`` 表示。
+其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2i+1]`` 表示。
 
 一个例子:
 

doc/fluid/api_cn/layers_cn/reduce_all_cn.rst

@@ -22,16 +22,19 @@ reduce_all
 ..  code-block:: python
      
      
-        # x是一个布尔型Tensor，元素如下:
-        #    [[True, False]
-        #     [True, True]]
-        # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
         import paddle.fluid as fluid
         import paddle.fluid.layers as layers
         import numpy as np
-        fluid.layers.reduce_all(x)  # False
-        fluid.layers.reduce_all(x, dim=0)  # [True, False]
-        fluid.layers.reduce_all(x, dim=-1)  # [False, True]
-        fluid.layers.reduce_all(x, dim=1,
-                                 keep_dim=True)  # [[False], [True]]
+
+        # x是一个布尔型Tensor，元素如下:
+        #    [[True, False]
+        #     [True, True]]
+        x = layers.assign(np.array([[1, 0], [1, 1]], dtype='int32'))
+        x = layers.cast(x, 'bool')
+
+        out = layers.reduce_all(x)  # False
+        out = layers.reduce_all(x, dim=0)  # [True, False]
+        out = layers.reduce_all(x, dim=-1)  # [False, True]
+        
+        out = layers.reduce_all(x, dim=1, keep_dim=True)  # [[False], [True]]
      

doc/fluid/api_cn/layers_cn/reduce_any_cn.rst

@@ -22,19 +22,21 @@ reduce_any
 ..  code-block:: python
      
      
-        # x是一个布尔型Tensor，元素如下:
-        #    [[True, False]
-        #     [False, False]]
-        # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
         import paddle.fluid as fluid
         import paddle.fluid.layers as layers
         import numpy as np
-        fluid.layers.reduce_any(x)  # True
-        fluid.layers.reduce_any(x, dim=0)  # [True, False]
-        fluid.layers.reduce_any(x, dim=-1)  # [True, False]
-        fluid.layers.reduce_any(x, dim=1,
-                                 keep_dim=True)  # [[True], [False]]
 
+        # x是一个布尔型Tensor，元素如下:
+        #    [[True, False]
+        #     [False, False]]
+        x = layers.assign(np.array([[1, 0], [0, 0]], dtype='int32'))
+        x = layers.cast(x, 'bool')
+
+        out = layers.reduce_any(x)  # True
+        out = layers.reduce_any(x, dim=0)  # [True, False]
+        out = layers.reduce_any(x, dim=-1)  # [True, False]
+        out = layers.reduce_any(x, dim=1,
+                         keep_dim=True)  # [[True], [False]]
 
 
 

doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst

@@ -15,9 +15,12 @@ roi_perspective_transform
     - **spatial_scale** (float) - 空间尺度因子，用于缩放ROI坐标，默认：1.0。
 
 返回：
- ``ROIPerspectiveTransformOp`` 的输出，它是一个4维张量，形为 (num_rois,channels,transformed_h,transformed_w)
+三变量的一个元组。 (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)。
 
-返回类型：变量（Variable）
+返回类型：元组
 
 **代码示例**：
 
@@ -27,7 +30,7 @@ roi_perspective_transform
 
     x = fluid.layers.data(name='x', shape=[256, 28, 28], dtype='float32')
     rois = fluid.layers.data(name='rois', shape=[8], lod_level=1, dtype='float32')
-    out = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0)
+    out, mask, transform_matrix = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0)
 
 
 

doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst

@@ -32,7 +32,7 @@ sequence_enumerate
 ..  code-block:: python
 
       import paddle.fluid as fluid
-      x = fluid.layers.data(shape[-1, 1], dtype='int32', lod_level=1)
+      x = fluid.layers.data(name='x',shape=[-1, 1], dtype='int32', lod_level=1)
       out = fluid.layers.sequence_enumerate(input=x, win_size=3, pad_value=0)
 
 

doc/fluid/api_cn/layers_cn/shard_index_cn.rst

+.. _cn_api_fluid_layers_shard_index:
+
+shard_index
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.shard_index(input, index_num, nshards, shard_id, ignore_value=-1)
+
+该层为输入创建碎片化索引，通常在模型和数据并行混合训练时使用，索引数据（通常是标签）应该在每一个trainer里面被计算，通过
+::
+
+    assert index_num % nshards == 0
+
+    shard_size = index_num / nshards
+
+    如果 x / shard_size == shard_id
+
+    y = x % shard_size  
+
+    否则
+
+    y = ignore_value
+
+我们使用分布式 ``one-hot`` 表示来展示该层如何使用， 分布式的 ``one-hot`` 表示被分割为多个碎片, 碎片索引里不为1的都使用0来填充。为了在每一个trainer里面创建碎片化的表示，原始的索引应该先进行计算(i.e. sharded)。我们来看个例子：
+
+.. code-block:: text
+
+    X 是一个整形张量
+    X.shape = [4, 1]
+    X.data = [[1], [6], [12], [19]]
+
+    假设 index_num = 20 并且 nshards = 2, 我们可以得到 shard_size = 10
+
+    如果 shard_id == 0, 我们得到输出:
+    Out.shape = [4, 1]
+    Out.data = [[1], [6], [-1], [-1]]
+    如果 shard_id == 1, 我们得到输出:
+    Out.shape = [4, 1]
+    Out.data = [[-1], [-1], [2], [9]]
+
+    上面的例子中默认 ignore_value = -1
+
+参数：
+        - **input** (Variable）-  输入的索引，最后的维度应该为1
+        - **index_num** (scalar) - 定义索引长度的整形参数
+        - **nshards** (scalar) - shards数量
+        - **shard_id** (scalar) - 当前碎片的索引
+        - **ignore_value** (scalar) - 超出碎片索引范围的整型值
+
+返回： 输入的碎片索引
+
+返回类型：    Variable
+
+**代码示例：**
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    shard_label = fluid.layers.shard_index(input=label,
+                                       index_num=20,
+                                       nshards=2,
+                                       shard_id=0)
+
+
+
+
+

doc/fluid/api_cn/layers_cn/sign_cn.rst

@@ -18,9 +18,11 @@ sign
 
 ..  code-block:: python
 
-    # [1, 0, -1]
     import paddle.fluid as fluid
-    data = fluid.layers.sign(np.array([3, 0, -2]))
+    import numpy as np
+
+    # [1, 0, -1]
+    data = fluid.layers.sign(np.array([3, 0, -2], dtype='int32'))
 
 
 

doc/fluid/api_cn/layers_cn/sin_cn.rst

@@ -12,7 +12,6 @@ sin
 
 
 参数:
-
     - **x** - sin算子的输入
     - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
 

doc/fluid/api_cn/layers_cn/size_cn.rst

+.. _cn_api_fluid_layers_size:
+
+size
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.size(input)
+
+size层
+
+返回一个形为[1]的int64类型的张量，代表着输入张量的元素的数量。
+
+
+参数：
+    - **input** - 输入的变量
+
+
+返回：输入变量的元素的数量。
+
+**代码示例**：
+
+.. code-block:: python
+
+        import paddle.fluid.layers as layers
+
+        input = layers.data(
+                name="input", shape=[3, 100], dtype="float32", append_batch_size=False)
+        rank = layers.size(input) # 300
\ No newline at end of file

doc/fluid/api_cn/layers_cn/soft_relu_cn.rst

@@ -7,7 +7,7 @@ soft_relu
 
 SoftRelu 激活函数
 
-.. math::   out=ln(1+exp(max(min(x,threshold),threshold))
+.. math::   out=ln(1+exp(max(min(x,threshold),threshold)))
 
 参数:
     - **x** (variable) - SoftRelu operator的输入

doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst

@@ -44,7 +44,7 @@ space_to_depth
     space_to_depthed = fluid.layers.space_to_depth(
         x=data, blocksize=2)
 
-    exe = fluid.Executor(fluid.CUDAPlace(0))
+    exe = fluid.Executor(fluid.CPUPlace())
     data_np = np.arange(0,16).reshape((1,4,2,2)).astype('float32')
     out_main = exe.run(fluid.default_main_program(),
                   feed={'data': data_np},

doc/fluid/api_cn/layers_cn/split_cn.rst

@@ -27,7 +27,7 @@ split
     input = fluid.layers.data(
          name="input", shape=[3, 9, 5], dtype="float32")
 
-    x0, x1, x2 = fluid.layers.split(x, num_or_sections=3, dim=2)
+    x0, x1, x2 = fluid.layers.split(input, num_or_sections=3, dim=2)
     # x0.shape  [-1, 3, 3, 5]
     # x1.shape  [-1, 3, 3, 5]
     # x2.shape  [-1, 3, 3, 5]

doc/fluid/api_cn/layers_cn/unfold_cn.rst

+.. _cn_api_fluid_layers_unfold:
+
+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]的输出。
+
+
+..  math::
+
+       dkernel[0] &= dilations[0] * (kernel\_sizes[0] - 1) + 1
+
+       dkernel[1] &= dilations[1] * (kernel\_sizes[1] - 1) + 1
+
+       hout &= \frac{H + paddings[0] + paddings[2] - dkernel[0]}{strides[0]} + 1
+
+       wout &= \frac{W + paddings[1] + paddings[3] - dkernel[1]}{strides[1]} + 1
+
+       Cout &= C * kernel\_sizes[0] * kernel\_sizes[1]
+
+       Lout &= hout * wout
+
+参数：
+    - **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]。
+
+
+返回： 
+    滑动block的输出张量，形状如上面所描述的[N, Cout, Lout]，Cout每一个滑动block里面值的总数，Lout是滑动block的总数.
+
+返回类型：（Variable）
+
+**代码示例**:
+
+.. code-block:: python
+    
+    import paddle.fluid as fluid
+    x = fluid.layers.data(name = 'data', shape = [3, 224, 224], dtype = 'float32')
+    y = fluid.layers.unfold(x, [3, 3], 1, 1, 1)
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/unique_cn.rst

+.. _cn_api_fluid_layers_unique:
+
+unique
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.unique(x, dtype='int32')
+
+unique为 ``x`` 返回一个unique张量和一个指向该unique张量的索引。
+
+参数：
+    - **x** (Variable) - 一个1维输入张量
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引张量的类型，int32，int64。
+
+返回：元组(out, index)。 ``out`` 为 ``x`` 的指定dtype的unique张量, ``index`` 是一个指向 ``out`` 的索引张量, 用户可以通过该函数来转换原始的 ``x`` 张量的索引。
+
+返回类型：元组(tuple)
+
+**代码示例**：
+
+.. code-block:: python
+
+    import numpy as np
+    import paddle.fluid as fluid
+    x = fluid.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32'))
+    out, index = fluid.layers.unique(x) # out is [2, 3, 1, 5]; index is [0, 1, 1, 2, 3, 1]
+
+
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst

+.. _cn_api_fluid_layers_unique_with_counts:
+
+unique_with_counts
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.unique_with_counts(x, dtype='int32')
+
+unique_with_count为 ``x`` 返回一个unique张量和一个指向该unique张量的索引以及 ``x`` 中unique元素的数量。
+
+参数：
+    - **x** (Variable) - 一个1维输入张量
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引张量的类型，int32，int64。
+
+返回：元组(out, index, count)。 ``out`` 为 ``x`` 的指定dtype的unique张量, ``index`` 是一个指向 ``out`` 的索引张量, 用户可以通过该函数来转换原始的 ``x`` 张量的索引， ``count`` 是 ``x`` 中unique元素的数量。
+
+返回类型：元组(tuple)
+
+**代码示例**：
+
+.. code-block:: python
+
+    import numpy as np
+    import paddle.fluid as fluid
+    x = fluid.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32'))
+    out, index, count = fluid.layers.unique_with_counts(x) # out is [2, 3, 1, 5];
+                                               # index is [0, 1, 1, 2, 3, 1];
+                                               # count is [1, 3, 1, 1]
+
+
+
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/var_conv_2d_cn.rst

+.. _cn_api_fluid_layers_var_conv_2d:
+
+var_conv_2d
+-------------------------------
+
+.. py:function:: paddle.fluid.layers.var_conv_2d(input, row, col, input_channel, output_channel, filter_size, stride=1, param_attr=None, act=None, dtype='float32', name=None)
+
+var_conv_2d层依据给定的参数来计算输出， ``input`` 、 ``row`` 和 ``col`` 都是1-level的 ``LodTensor`` 卷积操作与普通的conv2d卷积层一样，值得注意的是，输入数据的第二个维度即input.dim[1]应该为1。
+如果 ``input_channel`` 是2，并且给了如下的row lodTensor 和 col lodTensor:
+
+.. code-block:: text
+
+    row.lod = [[5, 4]]
+    col.lod = [[6, 7]]
+    输入是一个lodTensor:
+    input.lod = [[60, 56]]  # where 60 = input_channel * 5 * 6
+    input.dims = [116, 1]   # where 116 = 60 + 56
+    如果设置 output_channel 为3, filter_size 为 [3, 3], stride 为 [1, 1]:
+    output.lod = [[90, 84]] # where 90 = output_channel * [(5-1)/stride + 1] * [(6-1)/stride + 1]
+    output.dims = [174, 1]  # where 174 = 90 + 84
+
+参数:
+    - **input** (Variable) – dims[1]等于1的1-level的LodTensor。
+    - **row** (Variable) – 1-level的LodTensor提供height。
+    - **col** (Variable) – 1-level的LodTensor提供width。
+    - **input_channel** (int) – 输入通道的数目。
+    - **output_channel** (int) – 输出通道的数目。
+    - **filter_size** (int|tuple|None) – 过滤器尺寸。 如果是元组，则应当为两个整型数字(filter_size_H, filter_size_W)。否则，过滤器会变为正方形。
+    - **stride** (int|tuple) – 步长。 如果是元组，则应当为两个整型数字(stride_H, stride_W)。否则，stride_H = stride_W = stride。默认: stride = 1.
+    - **param_attr** (ParamAttr|None) – 为var_conv2d可学习的权重分配参数属性如果设置为None，或者ParamAttr的一个属性, var_conv2d将会创建ParamAttr做为param_attr。如果param_attr的初始化没有设定，参数将会以 \(Normal(0.0, std)\),进行初始化，\(std\) 为 \((\frac{2.0 }{filter\_elem\_num})^{0.5}\). 默认: None。
+    - **act** (str) – 激活类型，如果设置为None，则不会激活。默认:None
+    - **dtype** ('float32') – 输出与参数的数据类型
+    - **name** (str|None) – 层名。如果没有设置，将会被自动命名。默认: None。
+
+
+返回: 由该层指定LoD的输出变量
+
+返回类型: 变量(Variable)
+
+**代码示例**：
+
+.. code-block:: python
+
+    import numpy as np
+    from paddle.fluid import layers
+
+    x_lod_tensor = layers.data(name='x', shape=[1], lod_level=1)
+    row_lod_tensor = layers.data(name='row', shape=[6], lod_level=1)
+    col_lod_tensor = layers.data(name='col', shape=[6], lod_level=1)
+    out = layers.var_conv_2d(input=x_lod_tensor,
+                             row=row_lod_tensor,
+                             col=col_lod_tensor,
+                             input_channel=3,
+                             output_channel=5,
+                             filter_size=[3, 3],
+                             stride=1)
+
+
+
+
+
+
+

doc/fluid/api_cn/layers_cn/where_cn.rst

@@ -23,15 +23,20 @@ where
         import paddle.fluid as fluid
         import paddle.fluid.layers as layers
         import numpy as np
-        # condition为张量[True, False, True]
-        out = fluid.layers.where(condition) # [[0], [2]]
-     
-        # condition为张量[[True, False], [False, True]]
-        out = fluid.layers.where(condition) # [[0, 0], [1, 1]]
-     
-        # condition为张量[False, False, False]
-        out = fluid.layers.where(condition) # [[]]
-
+        # tensor 为 [True, False, True]
+        condition = layers.assign(np.array([1, 0, 1], dtype='int32'))
+        condition = layers.cast(condition, 'bool')
+        out = layers.where(condition) # [[0], [2]]
+
+        # tensor 为 [[True, False], [False, True]]
+        condition = layers.assign(np.array([[1, 0], [0, 1]], dtype='int32'))
+        condition = layers.cast(condition, 'bool')
+        out = layers.where(condition) # [[0, 0], [1, 1]]
+
+        # tensor 为 [False, False, False]
+        condition = layers.assign(np.array([0, 0, 0], dtype='int32'))
+        condition = layers.cast(condition, 'bool')
+        out = layers.where(condition) # [[]]
 
 
 

doc/fluid/api_cn/layers_cn/yolo_box_cn.rst

@@ -55,8 +55,9 @@ yolo_box
 
     import paddle.fluid as fluid
     x = fluid.layers.data(name='x', shape=[255, 13, 13], dtype='float32')
+    img_size = fluid.layers.data(name='img_size',shape=[2],dtype='int64')
     anchors = [10, 13, 16, 30, 33, 23]
-    loss = fluid.layers.yolo_box(x=x, img_size=608, class_num=80, anchors=anchors,
+    loss = fluid.layers.yolo_box(x=x, img_size=img_size, class_num=80, anchors=anchors,
                                     conf_thresh=0.01, downsample_ratio=32)
 
 

doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst

@@ -25,7 +25,7 @@ DetectionMAP
     - **background_label** (int) – 背景标签的索引，背景标签将被忽略。如果设置为-1，则所有类别将被考虑，默认为0。
     - **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/averageprecision/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。
+    - **ap_version** (string) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/2011/09/01/precision-recall/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。
 
 **代码示例**
 
@@ -61,9 +61,6 @@ DetectionMAP
         map_evaluator = fluid.metrics.DetectionMAP(nmsed_outs, gt_label, gt_box, difficult, class_num = 3)
         cur_map, accum_map = map_evaluator.get_map_var()
 
-        # 更详细的例子请参见
-        # https://github.com/PaddlePaddle/models/blob/43cdafbb97e52e6d93cc5bbdc6e7486f27665fc8/PaddleCV/object_detection
-
 
 
 .. py:method:: get_map_var()

doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst

@@ -29,8 +29,20 @@ LARS支持的Momentum优化器
 .. code-block:: python
 
     import paddle.fluid as fluid
-    optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
-    optimizer.minimize(cost)
+
+    np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+    inp = fluid.layers.data(
+        name="inp", shape=[2, 2], append_batch_size=False)
+    out = fluid.layers.fc(inp, size=3)
+    out = fluid.layers.reduce_sum(out)
+    optimizer = fluid.optimizer.LarsMomentumOptimizer(learning_rate=0.001, momentum=0.9)
+    optimizer.minimize(out)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    exe.run(fluid.default_startup_program())
+    exe.run(
+        feed={"inp": np_inp},
+        fetch_list=[out.name])
 
 .. py:method:: apply_gradients(params_grads)
 

doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst

@@ -6,7 +6,7 @@ cuda_profiler
 .. py:function:: paddle.fluid.profiler.cuda_profiler(output_file, output_mode=None, config=None)
 
 
-CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpustarttimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler <https://developer.nvidia.com/nvidia-visual-profiler>`_ 工具来加载这个输出文件以可视化结果。
+CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpuendtimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler <https://developer.nvidia.com/nvidia-visual-profiler>`_ 工具来加载这个输出文件以可视化结果。
 
 
 参数:

doc/fluid/api_cn/profiler_cn/profiler_cn.rst

@@ -8,7 +8,7 @@ profiler
 profile interface 。与cuda_profiler不同，此profiler可用于分析CPU和GPU程序。默认情况下，它记录CPU和GPU kernel，如果想分析其他程序，可以参考教程来在c++代码中添加更多代码。
 
 
-如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <../advanced_usage/development/profiling/timeline_cn.html>`_
+如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/advanced_usage/development/profiling/timeline_cn.html>`_
 
 参数:
   - **state** (string) –  profiling state, 取值为 'CPU' 或 'GPU',  profiler 使用 CPU timer 或GPU timer 进行 profiling. 虽然用户可能在开始时指定了执行位置(CPUPlace/CUDAPlace)，但是为了灵活性，profiler不会使用这个位置。

doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst

@@ -9,7 +9,7 @@ start_profiler
 不能使用 ``fluid.profiler.profiler``
 
 
-如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <../advanced_usage/development/profiling/timeline_cn.html>`_
+如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <https://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/advanced_usage/development/profiling/timeline_cn.html>`_
 
 参数:
   - **state** (string) – profiling state, 取值为 'CPU' 或 'GPU' 或 'All', 'CPU' 代表只分析 cpu. 'GPU' 代表只分析 GPU . 'All' 会产生 timeline.

doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst

@@ -3,7 +3,7 @@
 memory_optimize
 -------------------------------
 
-.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
+.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True)
 
 历史遗留内存优化策略，通过在不同operators之间重用可变内存来减少总内存消耗。
 用一个简单的例子来解释该算法：

doc/fluid/api_guides/low_level/layers/detection.rst

@@ -69,7 +69,7 @@ SSD
 
 * ssd_loss：通过位置偏移预测值，置信度，检测框位置和真实框位置和标签计算损失。API Reference 请参考 :ref:`cn_api_fluid_layers_ssd_loss`
 
-* detection map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`cn_api_fluid_layers_detection_map`
+* detection_map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`cn_api_fluid_layers_detection_map`
 
 YOLO V3
 ---------------