update api_cn of develop-8-15 (#1111)

doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst

@@ -13,32 +13,14 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
 
     dataset = paddle.fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
 
-
-.. py:method:: load_into_memory()
-
-向内存中加载数据。
-
-**代码示例**:
-
-.. code-block:: python
-
-    import paddle.fluid as fluid
-    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
-    filelist = ["a.txt", "b.txt"]
-    dataset.set_filelist(filelist)
-    dataset.load_into_memory()
-
-
 .. py:method:: set_queue_num(queue_num)
 
-设置 ``Dataset`` 的输出队列数量，训练进程从队列中获取数据。
-
+设置 ``Dataset`` 输出队列数量，训练进程会从队列中获取数据。
 
+参数：
+    - **queue_num** (int) - dataset输出队列数量
 
-参数:
-    - **queue_num** (int) - dataset输出队列的数量。
-
-**代码示例**：
+**代码示例**:
 
 .. code-block:: python
 
@@ -61,7 +43,6 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
     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。
@@ -72,6 +53,56 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
     - **min_merge_size** (int) - 合并的最小数量。默认为2。
     - **keep_unmerged_ins** (bool) - 是否保留没有合并的样本，比如有着独特id的样本，或者重复id的数量小于 ``min_merge_size`` 的样本。
 
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
+    dataset.set_merge_by_lineid()
+
+.. py:method:: load_into_memory()
+
+向内存中加载数据。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
+    filelist = ["a.txt", "b.txt"]
+    dataset.set_filelist(filelist)
+    dataset.load_into_memory()
+
+.. py:method:: preload_into_memory()
+
+向内存中以异步模式加载数据。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
+    filelist = ["a.txt", "b.txt"]
+    dataset.set_filelist(filelist)
+    dataset.preload_into_memory()
+    dataset.wait_preload_done()
+
+.. py:method:: wait_preload_done()
+
+等待 ``preload_into_memory`` 完成。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
+    filelist = ["a.txt", "b.txt"]
+    dataset.set_filelist(filelist)
+    dataset.preload_into_memory()
+    dataset.wait_preload_done()
+
 .. py:method:: local_shuffle()
 
 局域shuffle。
@@ -181,5 +212,143 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类
     print dataset.get_shuffle_data_size(fleet)
 
 
+.. py:method:: set_batch_size(batch_size)
+
+设置batch size。在训练期间生效。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_batch_size(128)
+
+参数：
+    - **batch_size** (int) - batch size
+
+.. py:method:: set_fea_eval(record_candidate_size, fea_eval=True)
+
+设置特征打乱特征验证模式，来修正特征level的重要性， 特征打乱需要 ``fea_eval`` 被设置为True。
+
+参数：
+    - **record_candidate_size** (int) - 打乱一个特征的候选实例大小
+    - **fea_eval** (bool) - 是否设置特征验证模式来打乱特征，默认为True。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
+    dataset.set_fea_eval(1000000, True)
+
+.. py:method:: desc()
+
+为 ``DataFeedDesc`` 返回一个缓存信息。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    print(dataset.desc())
+
+返回：一个字符串信息
+
+.. py:method:: set_filelist(filelist)
+
+在当前的worker中设置文件列表。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_filelist(["a.txt", "b.txt"])
+
+参数：
+    - **filelist** (list) - 文件列表
+
+.. py:method:: set_hdfs_config(fs_name, fs_ugi)
+
+设置hdfs配置：fs名称与ugi。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_hdfs_config("my_fs_name", "my_fs_ugi")
+
+参数：
+    - **fs_name** (str) - fs名称
+    - **fs_ugi** (str) - fs ugi
+
+.. py:method:: set_pipe_command(pipe_coommand)
+
+在当前的 ``dataset`` 中设置pipe命令。pipe命令只能使用UNIX的pipe命令
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_pipe_command("python my_script.py")
+
+参数：
+    - **pipe_command** (str) - pipe命令
+
+.. py:method:: set_thread(thread_num)
+
+设置进程数量，等于readers的数量。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_thread(12)
+
+参数：
+    - **thread_num** (int) - 进程数量
+
+.. py:method:: set_use_var(var_list)
+
+设置将要使用的 ``Variable`` 。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_use_var([data, label])
+
+参数：
+    - **var_list** (list) - variable 列表
+
+.. py:method:: slots_shuffle(slots)
+
+该方法是在特征层次上的一个打乱方法，经常被用在有着较大缩放率实例的稀疏矩阵上，为了比较metric，比如auc，在一个或者多个有着baseline的特征上做特征打乱来验证特征level的重要性。
+
+参数：
+    - **slots** (list[string]) - 要打乱特征的集合
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
+    dataset.set_merge_by_lineid()
+    #支持slot 0
+    dataset.slots_shuffle([‘0’])
+
 
 

doc/fluid/api_cn/dataset_cn/QueueDataset_cn.rst

@@ -47,3 +47,139 @@ QueueDataset中不支持全局shuffle，可能抛出NotImplementedError
     dataset = fluid.DatasetFactory().create_dataset("QueueDataset")
     dataset.global_shuffle(fleet)
 
+.. py:method:: desc()
+
+为 ``DataFeedDesc`` 返回一个缓存信息。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    print(dataset.desc())
+
+返回：一个字符串信息
+
+.. py:method:: set_batch_size(batch_size)
+
+设置batch size。在训练期间生效。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_batch_size(128)
+
+参数：
+    - **batch_size** (int) - batch size
+
+.. py:method:: set_fea_eval(record_candidate_size,fea_eval)
+
+参数：
+    - **record_candidate_size** (int) - 打乱一个特征的候选实例大小
+    - **fea_eval** (bool) - 是否设置特征验证模式来打乱特征，默认为True。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
+    dataset.set_fea_eval(1000000, True)
+
+.. py:method:: set_filelist(filelist)
+
+在当前的worker中设置文件列表。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_filelist(["a.txt", "b.txt"])
+
+参数：
+    - **filelist** (list) - 文件列表
+
+.. py:method:: set_hdfs_config(fs_name, fs_ugi)
+
+设置hdfs配置：fs名称与ugi。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_hdfs_config("my_fs_name", "my_fs_ugi")
+
+参数：
+    - **fs_name** (str) - fs名称
+    - **fs_ugi** (str) - fs ugi
+
+.. py:method:: set_pipe_command(pipe_coommand)
+
+在当前的 ``dataset`` 中设置pipe命令。pipe命令只能使用UNIX的pipe命令
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_pipe_command("python my_script.py")
+
+参数：
+    - **pipe_command** (str) - pipe命令
+
+.. py:method:: set_thread(thread_num)
+
+设置进程数量，等于readers的数量。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_thread(12)
+
+参数：
+    - **thread_num** (int) - 进程数量
+
+.. py:method:: set_use_var(var_list)
+
+设置将要使用的 ``Variable`` 。
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset()
+    dataset.set_use_var([data, label])
+
+参数：
+    - **var_list** (list) - variable 列表
+
+.. py:method:: slots_shuffle(slots)
+
+该方法是在特征层次上的一个打乱方法，经常被用在有着较大缩放率实例的稀疏矩阵上，为了比较metric，比如auc，在一个或者多个有着baseline的特征上做特征打乱来验证特征level的重要性。
+
+参数：
+    - **slots** (list[string]) - 要打乱特征的集合
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
+    dataset.set_merge_by_lineid()
+    #支持slot 0
+    dataset.slots_shuffle([‘0’])
+

doc/fluid/api_cn/fluid_cn.rst

@@ -29,7 +29,6 @@ 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/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/layers_cn.rst

@@ -41,7 +41,6 @@ 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
@@ -142,7 +141,6 @@ 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
@@ -241,7 +239,6 @@ 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
@@ -250,7 +247,6 @@ 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
@@ -284,14 +280,10 @@ 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/uniform_random_batch_size_like_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/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/embedding_cn.rst

@@ -11,13 +11,13 @@ embedding
 所有的输入变量都作为局部变量传入LayerHelper构造器
 
 参数：
-    - **input** (Variable)-包含IDs信息的int64的张量变量。
-    - **size** (tuple|list)-查找表参数的维度。应当有两个参数，一个代表嵌入矩阵字典的大小，一个代表每个嵌入向量的大小。
-    - **is_sparse** (bool)-代表是否用稀疏更新的标志
-    - **is_distributed** (bool)-是否从远程参数服务端运行查找表
-    - **padding_idx** (int|long|None)-如果为 ``None`` ，对查找结果无影响。如果padding_idx不为空，表示一旦查找表中找到input中对应的 ``padding_idx``，则用0填充输出结果。如果 :math:`padding\_idx<0` ,在查找表中使用的 ``padding_idx`` 值为 :math:`size[0]+dim` 。
-    - **param_attr** (ParamAttr)-该层参数
-    - **dtype** (np.dtype|core.VarDesc.VarType|str)-数据类型：float32,float_16,int等。
+    - **input** (Variable) - 包含IDs信息的int64的张量变量。输入IDs的值应该(0<= id < size[0])。
+    - **size** (tuple|list) - 查找表参数的维度。应当有两个参数，一个代表嵌入矩阵字典的大小，一个代表每个嵌入向量的大小。
+    - **is_sparse** (bool) - 代表是否用稀疏更新的标志
+    - **is_distributed** (bool) - 是否从远程参数服务端运行查找表
+    - **padding_idx** (int|long|None) - 只要查找发现（padding_idx）在ids中，就会输出全0填充的数据，如果为 ``None`` ，对输出结果无影响。如果（padding_idx<0），则（padding_idx<0）会自动转换为（size[0] + padding_idx）,默认为None。
+    - **param_attr** (ParamAttr) - 该层参数
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 数据类型：float32,float_16,int等。
 
 返回：张量，存储已有输入的嵌入矩阵。
 

doc/fluid/api_cn/layers_cn/image_resize_cn.rst

@@ -7,12 +7,14 @@ image_resize
 
 调整一个batch中图片的大小。
 
-输入张量的shape为(num_batch, channels, in_h, in_w)，并且调整大小只适用于最后两个维度(高度和宽度)。
+输入张量的shape为(num_batches, channels, in_h, in_w)或者(num_batches, channels, in_d, in_h, in_w)，并且调整大小只适用于最后两、三个维度(深度，高度和宽度)。
 
 支持重新取样方法:
 
     BILINEAR：双线性插值
 
+    TRALINEAR：三线插值
+
     NEAREST：最近邻插值
 
 
@@ -20,6 +22,8 @@ image_resize
 
 双线性插值是线性插值的扩展，用于在直线2D网格上插值两个变量（例如，该操作中的H方向和W方向）的函数。 关键思想是首先在一个方向上执行线性插值，然后在另一个方向上再次执行线性插值。
 
+三线插值是线性插值的一种扩展，是3参数的插值方程（比如op里的D,H,W方向），在三个方向上进行线性插值。
+
 Align_corners和align_mode是可选参数，插值的计算方法可以由它们选择。
 
 示例:
@@ -77,6 +81,28 @@ Align_corners和align_mode是可选参数，插值的计算方法可以由它们
           H_out = H_{in} * scale_{factor}
           W_out = W_{in} * scale_{factor}
 
+      Trilinear interpolation:
+
+      if:
+          align_corners = False , align_mode = 0
+
+          input : (N,C,D_in,H_in,W_in)
+          output: (N,C,D_out,H_out,W_out) where:
+
+          D_out = (D_{in}+0.5) * scale_{factor} - 0.5
+          H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+          W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+
+      else:
+
+          input : (N,C,D_in,H_in,W_in)
+          output: (N,C,D_out,H_out,W_out) where:
+
+          D_out = D_{in} * scale_{factor}
+          H_out = H_{in} * scale_{factor}
+          W_out = W_{in} * scale_{factor}
+
 
 有关最近邻插值的详细信息，请参阅维基百科：
 https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation。
@@ -84,26 +110,30 @@ https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation。
 有关双线性插值的详细信息，请参阅维基百科：
 https://en.wikipedia.org/wiki/Bilinear_interpolation。
 
+有关三线插值的详细信息，请参阅维基百科：
+https://en.wikipedia.org/wiki/Trilinear_interpolation。
+
 参数:
-    - **input** (Variable) - 图片调整层的输入张量，这是一个shape=4的张量(num_batch, channels, in_h, in_w)
-    - **out_shape** (list|tuple|Variable|None) - 图片调整层的输出，shape为(out_h, out_w)。默认值:None
+    - **input** (Variable) - 图片调整层的输入张量，这是一个shape=4的张量(num_batches, channels, in_h, in_w)或者5维张量(num_batches, channels, in_d, in_h, in_w)。
+    - **out_shape** (list|tuple|Variable|None) - 图片调整层的输出，输入为4D张量时shape为(out_h, out_w)。输入为5D张量时shape为(out_d, out_h, out_w)，默认值:None
     - **scale** (float|None)-输入的高度或宽度的乘数因子 。 out_shape和scale至少要设置一个。out_shape的优先级高于scale。默认值:None
     - **name** (str|None) - 该层的名称(可选)。如果设置为None，该层将被自动命名
-    - **resample** (str) - 重采样方法。目前只支持“双线性”。默认值:双线性插值
+    - **resample** (str) - 重采样方法。支持“双线性”,“三线性”,“临近插值”,。默认值:双线性插值
     - **actual_shape** (Variable) - 可选输入，用于动态指定输出形状。如果指定actual_shape，图像将根据给定的形状调整大小，而不是根据指定形状的 :code:`out_shape` 和 :code:`scale` 进行调整。也就是说， :code:`actual_shape` 具有最高的优先级。如果希望动态指定输出形状，建议使用 :code:`actual_shape` 而不是 :code:`out_shape` 。在使用actual_shape指定输出形状时，还需要设置out_shape和scale之一，否则在图形构建阶段会出现错误。默认值:None
     - **align_corners** （bool）- 一个可选的bool型参数，如果为True，则将输入和输出张量的4个角落像素的中心对齐，并保留角点像素的值。 默认值：True
     - **align_mode** （int）- 双线性插值的可选项。 可以是 '0' 代表src_idx = scale *（dst_indx + 0.5）-0.5；可以为'1' ，代表src_idx = scale * dst_index。
 
-返回： 4维tensor，shape为 (num_batches, channls, out_h, out_w).
+返回： 4维tensor，shape为 (num_batches, channls, out_h, out_w).或者5维tensor，shape为 (num_batches, channls, out_d, out_h, out_w).
 
 返回类型: 变量（variable）
 
 抛出异常：
     - :code:`TypeError` - out_shape应该是一个列表、元组或变量。
     - :code:`TypeError` - actual_shape应该是变量或None。
-    - :code:`ValueError` - image_resize的"resample"只能是"BILINEAR"或"NEAREST"。
+    - :code:`ValueError` - image_resize的"resample"只能是"BILINEAR"或"TRILINEAR"或"NEAREST"。
     - :code:`ValueError` - out_shape 和 scale 不可同时为 None。
-    - :code:`ValueError` - out_shape 的长度必须为 2。
+    - :code:`ValueError` - out_shape 的长度必须为2如果输入是4D张量。
+    - :code:`ValueError` - out_shape 的长度必须为3如果输入是5D张量。
     - :code:`ValueError` - scale应大于0。
     - :code:`TypeError`  - align_corners 应为bool型。
     - :code:`ValueError` - align_mode 只能取 ‘0’ 或 ‘1’。

doc/fluid/api_cn/layers_cn/image_resize_short_cn.rst

@@ -12,7 +12,7 @@ image_resize_short
         - **out_short_len** (int) -  输出图像的短边长度。
         - **resample** (str) - resample方法，默认为双线性插值。
 
-返回： 4维张量，shape为(num_batch, channls, out_h, out_w)
+返回： 4维张量，shape为(num_batches, channels, out_h, out_w)
 
 返回类型: 变量（variable）
 

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/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/resize_bilinear_cn.rst

@@ -51,7 +51,7 @@ align_corners和align_mode是可选参数，插值的计算方法可以由它们
 
 
 参数:
-    - **input** (Variable) - 双线性插值的输入张量，是一个shape为(N x C x h x w)的4d张量。
+    - **input** (Variable) - 输入为4d张量。
     - **out_shape** (list|tuple|Variable|None) - 调整双线性层的输出形状，形式为(out_h, out_w)。默认值：None。
     - **scale** (float|None) - 用于输入高度或宽度的乘数因子。out_shape和scale至少要设置一个。out_shape的优先级高于scale。默认值：None。
     - **name** (str|None) - 输出变量名。
@@ -60,7 +60,7 @@ align_corners和align_mode是可选参数，插值的计算方法可以由它们
     - **align_mode** （int）- 双线性插值的可选项。 可以是'0'代表src_idx = scale *（dst_indx + 0.5）-0.5；可以为'1' ，代表src_idx = scale * dst_index。
 
 
-返回： 插值运算的输出张量，其各维度是(N x C x out_h x out_w)
+返回： 4D张量，shape为(num_batches, channels, out_h, out_w)
 
 
 **代码示例**

doc/fluid/api_cn/layers_cn/roi_align_cn.rst

@@ -16,7 +16,7 @@ Region of Interests align(直译：有意义、有价值选区对齐) 用于实
 
 参数:
   - **input** (Variable) – (Tensor) 该运算的的输入张量，形为(N,C,H,W)。其中 N 为batch大小, C 为输入通道的个数, H 特征高度, W 特征宽度
-  - **rois** (Variable) – 待池化的ROIs (Regions of Interest)
+  - **rois** (Variable) – 待池化的ROIs (Regions of Interest)，形为（num_rois,4）的2D张量，lod level 为1。给定比如[[x1,y1,x2,y2], ...],(x1,y1)为左上点坐标，(x2,y2)为右下点坐标。
   - **pooled_height** (integer) – (默认为1), 池化后的输出高度
   - **pooled_width** (integer) – (默认为1), 池化后的输出宽度
   - **spatial_scale** (float) – (默认为1.0),乘法性质空间标尺因子，池化时，将RoI坐标变换至运算采用的标度

doc/fluid/api_cn/layers_cn/roi_pool_cn.rst

@@ -18,7 +18,7 @@ Faster-RCNN.使用了roi池化。roi关于roi池化请参考 https://stackoverfl
 
 参数:
     - **input** (Variable) - 张量，ROIPoolOp的输入。输入张量的格式是NCHW。其中N为batch大小，C为输入通道数，H为特征高度，W为特征宽度
-    - **roi** (Variable) -  roi区域。
+    - **rois** (Variable) – 待池化的ROIs (Regions of Interest)，形为（num_rois,4）的2D张量，lod level 为1。给定比如[[x1,y1,x2,y2], ...],(x1,y1)为左上点坐标，(x2,y2)为右下点坐标。
     - **pooled_height** (integer) - (int，默认1)，池化输出的高度。默认:1
     - **pooled_width** (integer) -  (int，默认1) 池化输出的宽度。默认:1
     - **spatial_scale** (float) - (float，默认1.0)，用于将ROI coords从输入比例转换为池化时使用的比例。默认1.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/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/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)
-
-
-
-
-
-
-