Fix some op API document, paddle tools group. (#1257)

* test=document_preview
Fix the op API of diag, greater_equal, greater_than, less_equal, linspace, not_equal, rank, reduce_all, reduce_any, rsqrt, sign, unique_with_counts, where, zeros_like.

* test=document_preview
Fix some problems in fisrt commit, main format problem.

* test=document_preview
Fix document, the return type of greater_equal, greater_than, less_equal, not_equal.

* test=document_preview
Fix the format in doc of op rsqrt.

doc/fluid/api_cn/layers_cn/diag_cn.rst

@@ -5,14 +5,14 @@ diag
 
 .. py:function:: paddle.fluid.layers.diag(diagonal)
 
-该功能创建一个方阵，含有diagonal指定的对角线值。
+该OP创建一个方阵，使用输入diagonal来指定方阵的对角线元素的值。
 
 参数：
-    - **diagonal** (Variable|numpy.ndarray) - 指定对角线值的输入张量，其秩应为1。
+    - **diagonal** (Variable|numpy.ndarray) — 数据shape为 :math:`[N]` 一维Tensor，会把该Tensor的元素赋在方阵的对角线上。数据类型可以是 float32，float64，int32，int64。
 
-返回：存储着方阵的张量变量
+返回：存储着方阵的Tensor，对角线值是输入Tensor diagonal的值， 数据shape为 :math:`[N, N]` 二维Tensor。
 
-返回类型：变量（Variable）
+返回类型：Variable，数据类型和输入数据类型一致。
 
 **代码示例**：
 
@@ -24,7 +24,9 @@ diag
 
         import paddle.fluid as fluid
         import numpy as np
-        data = fluid.layers.diag(np.arange(3, 6, dtype='int32'))
+        diagonal = np.arange(3, 6, dtype='int32')
+        data = fluid.layers.diag(diagonal)
+        # diagonal.shape=(3,) data.shape=(3, 3)
 
 
 

doc/fluid/api_cn/layers_cn/greater_equal_cn.rst

@@ -5,25 +5,30 @@ greater_equal
 
 .. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None)
 
-该层逐元素地返回 :math:`x >= y` 的逻辑值，和重载算子 `>=` 相同。
+该OP逐元素地返回 :math:`x >= y` 的逻辑值，使用重载算子 `>=` 可以有相同的计算函数效果。
+
 
 参数：
-    - **x** (Variable) - *greater_equal* 的第一个操作数
-    - **y** (Variable) - *greater_equal* 的第二个操作数
-    - **cond** (Variable|None) - 可选的输出变量，存储 *greater_equal* 的结果
+    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
+    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
+    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape，数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据shape和数据类型需要和输入x一致。默认值为None。 
 
-返回：存储 *greater_equal* 的输出的张量变量。
+返回：输出结果的Tensor，数据的shape和输入x一致。
 
-返回类型：变量（Variable）
+返回类型：Variable，数据类型为bool类型。
 
 **代码示例**:
 
 .. 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)
+     import paddle.fluid.layers as layers
+     import numpy as np
+     label = layers.assign(np.array([2, 2], dtype='int32'))
+     limit = layers.assign(np.array([2, 3], dtype='int32'))
+     out = fluid.layers.greater_equal(x=label, y=limit) #out=[True, False]
+     out_1 = label >= limit #out1=[True, False]
+
 
 
 

doc/fluid/api_cn/layers_cn/greater_than_cn.rst

@@ -5,25 +5,28 @@ greater_than
 
 .. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None)
 
-该层逐元素地返回 :math:`x > y` 的逻辑值，和重载算子 `>` 相同。
+该OP逐元素地返回 :math:`x > y` 的逻辑值，使用重载算子 `>` 可以有相同的计算函数效果。
 
 参数：
-    - **x** (Variable) - *greater_than* 的第一个操作数
-    - **y** (Variable) - *greater_than* 的第二个操作数
-    - **cond** (Variable|None) - 可选的输出变量，存储 *greater_than* 的结果
+    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
+    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
+    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
 
-返回：存储 *greater_than* 的输出的张量变量。
+返回：输出结果的Tensor，数据的shape和输入x一致。
 
-返回类型：变量（Variable）
+返回类型：Variable，数据类型为bool类型。
 
 **代码示例**:
 
 .. 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)
+     import paddle.fluid.layers as layers
+     import numpy as np
+     label = layers.assign(np.array([2, 3], dtype='int32'))
+     limit = layers.assign(np.array([3, 2], dtype='int32'))
+     out = fluid.layers.greater_than(x=label, y=limit) #out=[False, True]
+     out1 = label > limit #out1=[False, True]
 
 
 

doc/fluid/api_cn/layers_cn/less_equal_cn.rst

@@ -5,25 +5,28 @@ less_equal
 
 .. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None)
 
-该层逐元素地返回 :math:`x <= y` 的逻辑值，和重载算子 `<=` 相同。
+该OP逐元素地返回 :math:`x <= y` 的逻辑值，使用重载算子 `<=` 可以有相同的计算函数效果。
 
 参数：
-    - **x** (Variable) - *less_equal* 的第一个操作数
-    - **y** (Variable) - *less_equal* 的第二个操作数
-    - **cond** (Variable|None) - 可选的输出变量，存储 *less_equal* 的结果
+    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
+    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
+    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
 
-返回：存储 *less_equal* 的输出的张量变量。
+返回：输出结果的Tensor，数据的shape和输入x一致。
 
-返回类型：变量（Variable）
+返回类型：Variable，数据类型为bool类型。
 
 **代码示例**:
 
 .. 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)
+     import paddle.fluid.layers as layers
+     import numpy as np
+     label = layers.assign(np.array([1, 3], dtype='int32'))
+     limit = layers.assign(np.array([1, 2], dtype='int32'))
+     out = fluid.layers.less_equal(x=label, y=limit) #out=[True, False]
+     out1 = label<= limit #out1=[True, False]
 
 
 

doc/fluid/api_cn/layers_cn/linspace_cn.rst

@@ -5,19 +5,17 @@ linspace
 
 .. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
 
-在给定区间内返回固定数目的均匀间隔的值。
+该OP在给定区间内返回固定数目的均匀间隔的值。
  
-第一个entry是start，最后一个entry是stop。在Num为1的情况下，仅返回start。类似numpy的linspace功能。
-
 参数：
-    - **start** (float|Variable)-序列中的第一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
-    - **stop** (float|Variable)-序列中的最后一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
-    - **num** (int|Variable)-序列中的entry数。 它是一个整型标量，或是一个数据类型为int32、形状为[1]的张量。
-    - **dtype** (string)-‘float32’|’float64’，输出张量的数据类型。
+    - **start** (float|Variable) – start是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **stop** (float|Variable) – end是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **num** (int|Variable) – num是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
+    - **dtype** (string) – 输出Tensor的数据类型，可以是‘float32’或者是‘float64’。
 
-返回：存储一维张量的张量变量
+返回：表示等间隔划分结果的1-D Tensor，该Tensor的shape大小为 :math:`[num]` ，在mum为1的情况下，仅返回包含start元素值的Tensor。
 
-返回类型：变量（Variable）
+返回类型：Variable
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/not_equal_cn.rst

@@ -5,26 +5,28 @@ not_equal
 
 .. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None)
 
-该层逐元素地返回 :math:`x != y` 的逻辑值，和重载算子 `!=` 相同。
+该OP逐元素地返回 :math:`x != y` 的逻辑值，使用重载算子 `!=` 可以有相同的计算函数效果。
 
 参数：
-    - **x** (Variable) - *not_equal* 的第一个操作数
-    - **y** (Variable) - *not_equal* 的第二个操作数
-    - **cond** (Variable|None) - 可选的输出变量，存储 *not_equal* 的结果
+    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
+    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
+    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
 
-返回：存储 *not_equal* 的输出的张量变量。
+返回：输出结果的Tensor，数据的shape和输入x一致。
 
-返回类型：变量（Variable）
+返回类型：变量（Variable），数据类型为bool类型。
 
 **代码示例**:
 
 .. 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)
+     import paddle.fluid.layers as layers
+     import numpy as np
+     label = layers.assign(np.array([2, 3], dtype='int32'))
+     limit = layers.assign(np.array([3, 2], dtype='int32'))
+     out = fluid.layers.not_equal(x=label, y=limit) #out=[True, True]
+     out1 = label != limit #out1=[True, True]
 
 
 

doc/fluid/api_cn/layers_cn/rank_cn.rst

@@ -5,24 +5,22 @@ rank
 
 .. py:function::  paddle.fluid.layers.rank(input)
 
-排序层
+该OP用于计算输入Tensor的维度（秩）。
 
-返回张量的维数，一个数据类型为int32的0-D Tensor。
+参数：
+    - **input** (Variable) — 输入input是shape为 :math:`[N_1, N_2, ..., N_k]` 的多维Tensor，数据类型可以任意类型。
 
-参数:
-    - **input** (Variable)：输入变量
+返回：输出Tensor的秩，是一个0-D Tensor。
 
-返回：输入变量的秩
-
-返回类型： 变量（Variable）
+返回类型：Variable，数据类型为int32。
 
 **代码示例**
 
 .. code-block:: python
 
        import paddle.fluid as fluid
-       input = layers.data(
+       input = fluid.layers.data(
             name="input", shape=[3, 100, 100], dtype="float32")
-       rank = layers.rank(input) # 4
+       rank = fluid.layers.rank(input) # rank=(3,)
 
 

doc/fluid/api_cn/layers_cn/reduce_all_cn.rst

@@ -5,17 +5,17 @@ reduce_all
 
 .. py:function:: paddle.fluid.layers.reduce_all(input, dim=None, keep_dim=False, name=None)
 
-计算给定维度上张量（Tensor）元素的与逻辑。
+该OP是对指定维度上的Tensor元素进行与逻辑（&）计算，并输出相应的计算结果。
 
 参数：
-          - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
-          - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
-          - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
+    - **input** （Variable）— 输入变量为多维Tensor或LoDTensor，数据类型需要为bool类型。
+    - **dim** （list | int，可选）— 与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。默认值为None。
+    - **keep_dim** （bool）— 是否在输出Tensor中保留减小的维度。如 keep_dim 为true，否则结果张量的维度将比输入张量小，默认值为False。
+    - **name** （str， 可选）— 这一层的名称。如果设置为None，则将自动命名这一层。默认值为None。
 
-返回：  减少维度之后的Tensor变量。
+返回：在指定dim上进行与逻辑计算的Tensor，数据类型为bool类型。
 
-返回类型：  变量（Variable）
+返回类型：Variable，数据类型为bool类型。
 
 **代码示例**
 
@@ -35,6 +35,8 @@ reduce_all
         out = layers.reduce_all(x)  # False
         out = layers.reduce_all(x, dim=0)  # [True, False]
         out = layers.reduce_all(x, dim=-1)  # [False, True]
+        # keep_dim=False, x.shape=(2,2), out.shape=(2,)
         
         out = layers.reduce_all(x, dim=1, keep_dim=True)  # [[False], [True]]
+        # keep_dim=True, x.shape=(2,2), out.shape=(2,1)
      

doc/fluid/api_cn/layers_cn/reduce_any_cn.rst

@@ -5,17 +5,17 @@ reduce_any
 
 .. py:function:: paddle.fluid.layers.reduce_any(input, dim=None, keep_dim=False, name=None)
 
-计算给定维度上张量（Tensor）元素的或逻辑。     
+该OP是对指定维度上的Tensor元素进行或逻辑（|）计算，并输出相应的计算结果。
 
 参数：
-          - **input** （Variable）：输入变量为Tensor或LoDTensor。
-          - **dim** （list | int | None）：或逻辑运算的维度。如果为None，则计算所有元素的或逻辑并返回仅包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
-          - **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
-          - **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
+    - **input** （Variable）— 输入变量为多维Tensor或LoDTensor，数据类型需要为bool类型。
+    - **dim** （list | int，可选）— 与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensoe变量，否则必须在  :math:`[−rank(input),rank(input))` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。默认值为None。
+    - **keep_dim** （bool）— 是否在输出Tensor中保留减小的维度。如 keep_dim 为true，否则结果张量的维度将比输入张量小，默认值为False。
+    - **name** （str，可选）— 这一层的名称（可选）。如果设置为None，则将自动命名这一层。默认值为None。
 
-返回：  减少维度之后的Tensor变量。
+返回：在指定dim上进行或逻辑计算的Tensor，数据类型为bool类型。
 
-返回类型：  变量（Variable）
+返回类型：Variable，数据类型为bool类型。
 
 **代码示例**
 
@@ -35,8 +35,12 @@ reduce_any
         out = layers.reduce_any(x)  # True
         out = layers.reduce_any(x, dim=0)  # [True, False]
         out = layers.reduce_any(x, dim=-1)  # [True, False]
+        # keep_dim=False, x.shape=(2,2), out.shape=(2,)
+
         out = layers.reduce_any(x, dim=1,
                          keep_dim=True)  # [[True], [False]]
+        # keep_dim=True, x.shape=(2,2), out.shape=(2,1)
+
 
 
 

doc/fluid/api_cn/layers_cn/rsqrt_cn.rst

@@ -5,20 +5,23 @@ rsqrt
 
 .. py:function:: paddle.fluid.layers.rsqrt(x, name=None)
 
-rsqrt激活函数
+该OP为rsqrt激活函数。
 
-请确保输入合法以免出现数字错误。
+注：输入x应确保为非 **0** 值，否则程序会抛异常退出。
+
+其运算公式如下：
 
 .. math::
     out = \frac{1}{\sqrt{x}}
 
 
 参数:
+    - **x** (Variable) – 输入是多维Tensor或LoDTensor，数据类型可以是float32和float64。 
+    - **name** (str，可选）— 这一层的名称（可选）。如果设置为None，则将自动命名这一层。默认值为None。
 
-    - **x** - rsqrt算子的输入 
-    - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
+返回：对输入x进行rsqrt激活函数计算后的Tensor或LoDTensor，数据shape和输入x的shape一致。
 
-返回：     rsqrt运算输出
+返回类型：Variable，数据类型和输入数据类型一致。
 
 **代码示例**：
 
@@ -28,5 +31,3 @@ rsqrt激活函数
         data = fluid.layers.data(name="input", shape=[32, 784])
         result = fluid.layers.rsqrt(data)
 
-
-

doc/fluid/api_cn/layers_cn/sign_cn.rst

@@ -5,14 +5,14 @@ sign
 
 .. py:function:: paddle.fluid.layers.sign(x)
 
-此函数返回x中每个元素的正负号：1代表正，-1代表负，0代表零。
+此OP对输入x中每个元素进行正负判断，并且输出正负判断值：1代表正，-1代表负，0代表零。
 
 参数：
-    - **x** (Variable|numpy.ndarray) – 输入张量。
+    - **x** (Variable|numpy.ndarray) – 进行正负值判断的多维Tensor或者是多维的numpy数组，数据类型为 float32，float64。
 
-返回：输出正负号张量，和x有着相同的形状和数据类型。
+返回：输出正负号Tensor，数据的shape大小和输入x的数据shape一致。
 
-返回类型：Variable
+返回类型：Variable，数据类型和输入数据类型一致。
 
 **代码示例**
 
@@ -21,10 +21,6 @@ sign
     import paddle.fluid as fluid
     import numpy as np
 
-    # [1, 0, -1]
-    data = fluid.layers.sign(np.array([3, 0, -2], dtype='int32'))
-
-
-
-
+    data = fluid.layers.sign(np.array([3.0, 0.0, -2.0], dtype='float32'))
+    # data=[1.0, 0.0, -1.0]
 

doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst

@@ -4,16 +4,20 @@ unique_with_counts
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.unique_with_counts(x, dtype='int32')
+该OP对输入Tensor元素进行去重，获取去重后结果Tensor，同时获取去重后结果在原始输入中的计数Tensor以及在原始输入中的索引Tensor。
 
-unique_with_count为 ``x`` 返回一个unique张量和一个指向该unique张量的索引以及 ``x`` 中unique元素的数量。
+注:该OP仅支持 **CPU** ，同时仅支持 **Tensor**
 
 参数：
-    - **x** (Variable) - 一个1维输入张量
-    - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引张量的类型，int32，int64。
+    - **x** (Variable) – 数据shape为 :math:`[N]` 的一维Tensor，数据类型为 float32，float64，int32，int64。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引和计数Tensor的类型，默认为 int32，数据类型需要为 int32或int64。
 
-返回：元组(out, index, count)。 ``out`` 为 ``x`` 的指定dtype的unique张量, ``index`` 是一个指向 ``out`` 的索引张量, 用户可以通过该函数来转换原始的 ``x`` 张量的索引， ``count`` 是 ``x`` 中unique元素的数量。
+返回: 
+    - **out** 表示对输入进行去重后结果一维Tensor，数据shape为 :math:`[K]` ，K和输入x的shape中的N可能不一致。 
+    - **index** 表示原始输入在去重后结果中的索引Tensor :math:`[N]` ，shape和输入x的shape一致。 
+    - **count** 表示去重后元素的计数结果Tensor，数据shape为 :math:`[K]` ，数据shape和out的shape一致。 
 
-返回类型：元组(tuple)
+返回类型：tuple，tuple中元素类型为Variable(Tensor)，输出中的out和输入x的数据类型一致，输出中index以及count的数据类型为 int32，int64。
 
 **代码示例**：
 
@@ -21,17 +25,9 @@ unique_with_count为 ``x`` 返回一个unique张量和一个指向该unique张
 
     import numpy as np
     import paddle.fluid as fluid
-    x = fluid.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32'))
+    x = fluid.layers.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]
-
-
-
-
-
-
-
-
-
+    # x.shape=(6,) out.shape=(4,), index.shape=(6,), count.shape=(4,)
 

doc/fluid/api_cn/layers_cn/where_cn.rst

@@ -4,17 +4,15 @@ where
 -------------------------------
 
 .. py:function:: paddle.fluid.layers.where(condition)
-     
-返回一个秩为2的int64型张量，指定condition中真实元素的坐标。
-     
-输出的第一维是真实元素的数量，第二维是condition的秩（维数）。如果没有真实元素，则将生成空张量。
+
+该OP计算输入元素中为True的元素在输入中的坐标（index）。
         
 参数：
-    - **condition** （Variable） - 秩至少为1的布尔型张量。
+    - **condition** （Variable）– 输入秩至少为1的多维Tensor，数据类型是bool类型。
 
-返回：存储一个二维张量的张量变量
+返回：输出condition元素为True的坐标（index），将所有的坐标（index）组成一个2-D的Tensor。
 
-返回类型：变量（Variable）
+返回类型：Variable，数据类型是int64。
      
 **代码示例**：
 
@@ -39,5 +37,3 @@ where
         out = layers.where(condition) # [[]]
 
 
-
-

doc/fluid/api_cn/layers_cn/zeros_like_cn.rst

@@ -5,17 +5,16 @@ zeros_like
 
 .. py:function:: paddle.fluid.layers.zeros_like(x, out=None)
 
-**zeros_like**
 
-该函数创建一个和x具有相同的形状和数据类型的全零张量
+该OP创建一个和x具有相同的形状和数据类型的全零Tensor。
 
 参数：
-    - **x** (Variable)-指定形状和数据类型的输入张量
-    - **out** (Variable)-输出张量
+    - **x** (Variable) – 指定输入为一个多维的Tensor，数据类型可以是bool，float32，float64，int32，int64。
+    - **out** (Variable|可选) – 如果为None，则创建一个Variable作为输出，创建后的Variable的数据类型，shape大小和输入变量x一致。如果是输入的一个Tensor，数据类型和数据shape大小需要和输入变量x一致。默认值为None。
     
-返回：存储输出的张量变量
+返回：返回一个多维的Tensor，具体的元素值和输入的数据类型相关，如果是bool类型的，则全False，其它均为0。数据shape大小和输入x一致。
 
-返回类型：变量（Variable）
+返回类型：Variable
 
 **代码示例**：
 
@@ -25,8 +24,3 @@ zeros_like
     x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
     data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]
 
-
-
-
-
-