modify fluid.layers.data to fluid.data in document (#1504)

modify fluid.layers.data to fluid.data and Synchronize Chinese doc and English doc

doc/fluid/api_cn/layers_cn/sequence_scatter_cn.rst

@@ -47,12 +47,12 @@ output[i][j]的值取决于能否在index中第i+1个区间中找到对应的数
 
 
 参数：
-      - **input** (Variable) - 维度为 :math:`[N, k_1 ... k_n]` 的Tensor， 数据类型支持float32，float64，int32，int64。
-      - **index** (Variable) - 包含index信息的LoDTensor，lod level必须等于1，数据类型必须为int64。
-      - **updates** (Variable) - 包含updates信息的LoDTensor，lod level和index一致，数据类型与input的数据类型一致。数据类型支持float32，float64，int32，int64。 
+      - **input** (Variable) - 维度为 :math:`[N, k_1 ... k_n]` 的Tensor， 支持的数据类型：float32，float64，int32，int64。
+      - **index** (Variable) - 包含index信息的LoDTensor，lod level必须等于1，支持的数据类型：int64。
+      - **updates** (Variable) - 包含updates信息的LoDTensor，lod level和index一致，数据类型与input的数据类型一致。支持的数据类型：float32，float64，int32，int64。 
       - **name**  (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
-返回： 包含更新了updates信息之后的Tensor，其维度和input的维度完全一致，数据类型与input的数据类型一致。
+返回：在input的基础上使用updates进行更新后得到的Tensor，它与input有相同的维度和数据类型。
 
 返回类型：Variable
 
@@ -64,9 +64,9 @@ output[i][j]的值取决于能否在index中第i+1个区间中找到对应的数
     import paddle.fluid as fluid
     import paddle.fluid.layers as layers
      
-    input = layers.data( name="x", shape=[3, 6], append_batch_size=False, dtype='float32' )
-    index = layers.data( name='index', shape=[12, 1], dtype='int64')
-    updates = layers.data( name='updates', shape=[12, 1], dtype='float32')
+    input = fluid.data( name="x", shape=[3, 6], dtype='float32' )
+    index = fluid.data( name='index', shape=[12, 1], dtype='int64', lod_level=1)
+    updates = fluid.data( name='updates', shape=[12, 1], dtype='float32', lod_level=1)
     output = fluid.layers.sequence_scatter(input, index, updates)
 
 

doc/fluid/api_cn/layers_cn/sequence_softmax_cn.rst

@@ -23,7 +23,7 @@ sequence_softmax
 
 输入Tensor的维度可为 :math:`[N，1]` 或者 :math:`[N]` ，推荐使用 :math:`[N]` 。
 
-例如，对有6个样本的batch，每个样本的长度为2，3，4，1，2，3，其lod信息为[[0, 3, 5, 9, 10, 12, 15]]，根据lod信息将第0维度划分为6份，在 :math:`X[0:3,:],X[3:5,:],X[5:9,:],X[9:10,:],X[10:12,:],X[12:15,:]`  中进行softmax运算。
+例如，对有6个样本的batch，每个样本的长度为3，2，4，1，2，3，其lod信息为[[0, 3, 5, 9, 10, 12, 15]]，根据lod信息将第0维度划分为6份，在 :math:`X[0:3,:],X[3:5,:],X[5:9,:],X[9:10,:],X[10:12,:],X[12:15,:]`  中进行softmax运算。
 
 ::
 
@@ -48,8 +48,8 @@ sequence_softmax
 
 
 参数：
-    - **input** (Variable) - 维度为 :math:`[N, 1]` 或者 :math:`[N]` 的LoDTensor，推荐使用 :math:`[N]` 。数据类型为float32或float64。
-    - **use_cudnn** (bool，可选) - 是否用cudnn核，仅当安装cudnn版本的paddle库且使用gpu训练或推理的时候生效。数据类型为bool型，默认值为False。
+    - **input** (Variable) - 维度为 :math:`[N, 1]` 或者 :math:`[N]` 的LoDTensor，推荐使用 :math:`[N]` 。支持的数据类型：float32，float64。
+    - **use_cudnn** (bool，可选) - 是否用cudnn核，仅当安装cudnn版本的paddle库且使用gpu训练或推理的时候生效。支持的数据类型：bool型。默认值为False。
     - **name**  (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回：根据区间计算softmax之后的LoDTensor，其维度与input的维度一致，数据类型与input的数据类型一致。
@@ -61,13 +61,13 @@ sequence_softmax
 .. code-block:: python
 
     import paddle.fluid as fluid
-    x = fluid.layers.data(name='x', shape=[7, 1],
+    x = fluid.data(name='x', shape=[7, 1],
                  dtype='float32', lod_level=1)
     x_sequence_softmax = fluid.layers.sequence_softmax(input=x)
     
-    y = fluid.layers.data(name='y', shape=[7],
+    y = fluid.data(name='y', shape=[7],
                  dtype='float32', lod_level=1)
-    x_sequence_softmax = fluid.layers.sequence_softmax(input=y)
+    y_sequence_softmax = fluid.layers.sequence_softmax(input=y)
 
 
 

doc/fluid/api_cn/layers_cn/sequence_unpad_cn.rst

@@ -11,12 +11,10 @@ sequence_unpad
 
 .. py:function:: paddle.fluid.layers.sequence_unpad(x, length, name=None)
 
-:red:`注意：该OP的输入为Tensor，输出为LoDTensor。`
+:red:`注意：该OP的输入为Tensor，输出为LoDTensor。该OP用于移除填充元素，与之对应，还存在进行数据填充的OP sequence_pad，详情见：`  :ref:`cn_api_fluid_layers_sequence_pad`
 
 该OP根据length的信息，将input中padding（填充）元素移除，并且返回一个LoDTensor。
 
-存在OP sequence_pad正好与之相反，能够进行填充数据，详情见： :ref:`cn_api_fluid_layers_sequence_pad`
-
 ::
 
     示例：
@@ -38,8 +36,8 @@ sequence_unpad
 
 
 参数:
-  - **x** (Variable) – 包含填充元素的Tensor，其维度大小不能小于2，数据类型支持float32, float64,int32, int64。
-  - **length** (Variable) – 存储每个样本实际长度信息的1D Tesnor，该Tensor的第0维必须与x参数的第0维一致。数据类型为int64。
+  - **x** (Variable) – 包含填充元素的Tensor，其维度大小不能小于2，支持的数据类型：float32, float64,int32, int64。
+  - **length** (Variable) – 存储每个样本实际长度信息的1D Tesnor，该Tensor维度的第0维必须与x维度的第0维一致。支持的数据类型：int64。
   - **name**  (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回：将输入的填充元素移除，并返回一个LoDTensor，其递归序列长度与length参数的信息一致，其数据类型和输入一致。
@@ -54,13 +52,13 @@ sequence_unpad
     import numpy
 
     # example 1:
-    x = fluid.layers.data(name='x', shape=[10, 5], dtype='float32')
-    len = fluid.layers.data(name='length', shape=[1], dtype='int64')
+    x = fluid.data(name='x', shape=[10, 5], dtype='float32')
+    len = fluid.data(name='length', shape=[10], dtype='int64')
     out = fluid.layers.sequence_unpad(x=x, length=len)
 
     # example 2:
     # 使用sequence_pad填充数据
-    input = fluid.layers.data(name='input', shape=[10, 5], dtype='float32', lod_level=1)
+    input = fluid.data(name='input', shape=[10, 5], dtype='float32', lod_level=1)
     pad_value = fluid.layers.assign(input=numpy.array([0.0], dtype=numpy.float32))
     pad_data, len = fluid.layers.sequence_pad(x=input, pad_value=pad_value)
 

doc/fluid/api_cn/layers_cn/uniform_random_batch_size_like_cn.rst

@@ -5,7 +5,8 @@ uniform_random_batch_size_like
 
 .. py:function:: paddle.fluid.layers.uniform_random_batch_size_like(input, shape, dtype='float32', input_dim_idx=0, output_dim_idx=0, min=-1.0, max=1.0, seed=0)
 
-该OP使用从均匀分布中采样的随机值初始化一个Tensor，且该Tensor指定维度将被设置为与输入Tensor指定维度相同的值。
+该OP使用从范围[min，max)内均匀分布采样的随机值初始化一个Tensor，且输出Tensor的
+指定维度将被设置为与输入Tensor指定维度相同的值。
 
 ::
 
@@ -13,6 +14,7 @@ uniform_random_batch_size_like
               给定：  
                    input =[[0.946741  , 0.1357001 , 0.38086128]]    # input.shape=[1,3]
                    shape=[2,4]
+              此时，output_dim_idx = 0， input_dim_idx = 0，result.shape[0] = input.shape[0]
               则：
                    result=[[ 0.3443427 , -0.23056602,  0.3477049 ,  0.06139076]]    # result.shape=[1,4]
 
@@ -22,19 +24,20 @@ uniform_random_batch_size_like
                    shape=[2,4]
                    input_dim_idx=1
                    output_dim_idx=1
+              此时，output_dim_idx = 1， input_dim_idx = 1，result.shape[1] = input.shape[1]
               则：
                    result=[[-0.23133647, -0.84195036,  0.21441269],
                           [-0.08774924,  0.25605237, -0.09403259]]    # result.shape=[2,3]
 
 参数：
-        - **input** （Variable）- 输入Tensor，input_dim_idx将指定其维度用来设置输出Tensor的指定维度。
-        - **shape** （list|tuple）- 输出Tensor的维度，其中output_dim_idx参数指定维度将被设置为与输入Tensor指定维度相同的值。数据类型为int。
-        - **input_dim_idx** （int，可选）- 输入Tensor指定维度的索引，数据类型为int。默认值为0。
-        - **output_dim_idx** （int，可选）- 输出Tensor指定维度的索引，数据类型为int。默认值为0。
-        - **min** （float，可选）- 均匀随机的最小值，为闭区间。数据类型为float。默认值为 1.0。
-        - **max** （float，可选）- 均匀随机的最大值，为开区间。数据类型为float。默认值为1.0。
-        - **seed** （int，可选）- 用于生成样本的随机种子。0表示使用系统生成的种子，数据类型为int。注意如果seed不为0，则此算子将始终每次生成相同的随机数。默认值为0。
-        - **dtype** （np.dtype | core.VarDesc.VarType | str，可选） - 输出Tensor的数据类型，支持float32（默认）， float64。
+        - **input** （Variable）- 输入Tensor，支持的数据类型：float32。
+        - **shape** （list|tuple）- 输出Tensor的维度，类型为list或者tuple。支持的数据类型：int。
+        - **input_dim_idx** （int，可选）- 输入Tensor指定维度的索引。该参数指定输入Tensor维度的值将用于调整输出Tensor维度的大小。支持的数据类型：int。默认值为0。
+        - **output_dim_idx** （int，可选）- 输出Tensor指定维度的索引。该参数指定输出Tensor的维度将被设置为与输入Tensor指定维度相同的值。支持的数据类型：int。默认值为0。
+        - **min** （float，可选）- 要生成的随机值范围的下限，min包含在范围中。支持的数据类型：float。默认值为 1.0。
+        - **max** （float，可选）- 要生成的随机值范围的上限，max不包含在范围中。支持的数据类型：float。默认值为1.0。
+        - **seed** （int，可选）- 用于生成样本的随机种子。0表示使用系统生成的种子，数据类型为int。注意如果seed不为0，则此算子将始终每次生成相同的随机数。支持的数据类型：int。默认值为0。
+        - **dtype** （np.dtype | core.VarDesc.VarType | str，可选） - 输出Tensor的数据类型。支持的数据类型：float32， float64，默认值为float32。
 
 返回:      表示随机初始化结果的Tensor，数据类型由dtype参数设置，该Tensor的维度由shape参数和输入Tensor的指定维度共同决定。
 
@@ -49,7 +52,7 @@ uniform_random_batch_size_like
     import paddle.fluid.layers as layers
     
     
-    input = layers.data(name="input", shape=[13, 11], dtype='float32')
+    input = fluid.data(name="input", shape=[13, 11], dtype='float32')
     # examp 1:
     # input_dim_idx和output_dim_idx使用默认值 
     out1 = layers.uniform_random_batch_size_like(input, [3, 5]) 

doc/fluid/api_cn/layers_cn/uniform_random_cn.rst

@@ -5,7 +5,7 @@ uniform_random
 
 .. py:function:: paddle.fluid.layers.uniform_random(shape, dtype='float32', min=-1.0, max=1.0, seed=0)
 
-该OP使用从均匀分布中抽样的随机值初始化一个Tensor。
+该OP使用从范围[min，max)内均匀分布采样的随机值初始化一个Tensor。
 
 ::
 
@@ -18,9 +18,9 @@ uniform_random
 参数：
     - **shape** (list|tuple|Variable)-输出Tensor的维度，shape类型支持list，tuple，Variable。如果shape类型是list或者tuple，它的元素可以是整数或者形状为[1]的Tensor，其中整数的数据类型为int，Tensor的数据类型为int64。如果shape的类型是Variable，则是1D的Tensor，Tensor的数据类型为int64。
     - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) – 输出Tensor的数据类型，支持float32（默认）， float64。
-    - **min** (float，可选）-均匀随机分布的最小值，为闭区间。数据类型为float。默认值为-1.0。
-    - **max** (float，可选)-均匀随机分布的最大值，为开区间。数据类型为float。默认值为1.0。
-    - **seed** (int，可选)-随机种子，用于生成样本。0表示使用系统生成的种子。注意如果种子不为0，该操作符每次都生成同样的随机数。数据类型为int。默认为 0。
+    - **min** (float，可选)-要生成的随机值范围的下限，min包含在范围中。支持的数据类型：float。默认值为-1.0。
+    - **max** (float，可选)-要生成的随机值范围的上限，max不包含在范围中。支持的数据类型：float。默认值为1.0。
+    - **seed** (int，可选)-随机种子，用于生成样本。0表示使用系统生成的种子。注意如果种子不为0，该操作符每次都生成同样的随机数。支持的数据类型：int。默认为 0。
 
 返回：表示一个随机初始化结果的Tensor，该Tensor的数据类型由dtype参数决定，该Tensor的维度由shape参数决定。
     
@@ -50,7 +50,7 @@ uniform_random
 
         # example 3:
         # attr shape is a Variable, the data type must be int64
-        var_shape = fluid.layers.data(name='var_shape',shape=[2],append_batch_size=False)
+        var_shape = fluid.data(name='var_shape', shape=[2])
         result_3 = fluid.layers.uniform_random(var_shape)
 
         exe = fluid.Executor(fluid.CPUPlace())