refine the doc of some OP for API2.0 (#2305)

doc/fluid/api_cn/layers_cn/eye_cn.rst

@@ -3,25 +3,20 @@
 eye
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32')
+.. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32', name=None)
 
-:alias_main: paddle.eye
-:alias: paddle.eye,paddle.tensor.eye,paddle.tensor.creation.eye
-:update_api: paddle.fluid.layers.eye
 
-
-
-该OP用来构建二维张量，或一个批次的二维张量。
+该OP用来构建二维Tensor，或一个批次的二维Tensor。
 
 参数：
-    - **num_rows** (int) - 该批次二维张量的行数，数据类型为非负int32。
-    - **num_columns** (int, 可选) - 该批次二维张量的列数，数据类型为非负int32。若为None，则默认等于num_rows。
-    - **batch_shape** (list(int), 可选) - 如若提供，则返回向量的主批次维度将为batch_shape。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 返回张量的数据类型，可为int32，int64，float16，float32，float64，默认数据类型为float32。
+    - **num_rows** (int) - 该批次二维Tensor的行数，数据类型为非负int32。
+    - **num_columns** (int, 可选) - 该批次二维Tensor的列数，数据类型为非负int32。若为None，则默认等于num_rows。
+    - **batch_shape** (list(int), 可选) - 如若提供，则返回Tensor的主批次维度将为batch_shape。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 返回Tensor的数据类型，可为int32，int64，float16，float32，float64，默认数据类型为float32。
+    - **name** (str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
     
-返回：shape为batch_shape + [num_rows, num_columns]的张量。
+返回： ``shape`` 为batch_shape + [num_rows, num_columns]的Tensor。
 
-返回类型：Variable（Tensor|LoDTensor）数据类型为int32，int64，float16，float32，float64的Tensor或者LoDTensor。
 
 抛出异常：
     - ``TypeError``: - 如果 ``dtype`` 的类型不是float16， float32， float64， int32， int64其中之一。

doc/fluid/api_cn/layers_cn/fill_constant_cn.rst

@@ -44,6 +44,6 @@ fill_constant
     positive_2 = fluid.layers.fill_constant([1], "int32", 2)
     data3 = fluid.layers.fill_constant(shape=[1, positive_2], dtype='float32', value=1.5) # data3=[1.5, 1.5]
 
-    # attr shape is an Variable Tensor.
+    # attr shape is a Variable Tensor.
     shape = fluid.layers.fill_constant([1,2], "int32", 2) # shape=[2,2]
     data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]]

doc/fluid/api_cn/layers_cn/linspace_cn.rst

@@ -3,22 +3,27 @@
 linspace
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
+.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype=None, name=None)
 
 
 
 
-该OP在给定区间内返回固定数目的均匀间隔的值。
+该OP返回一个Tensor，Tensor的值为在区间start和stop上均匀间隔的num个值，输出Tensor的长度为num。
+**注意：该OP不进行梯度计算**
  
 参数：
-    - **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’。
+    - **start** (float|Tensor) – ``start`` 是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **stop** (float|Tensor) – ``end`` 是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
+    - **dtype** (string, 可选) – 输出Tensor的数据类型，可以是float32或者是float64，如果dtype的数据类型为None，输出Tensor数据类型为float32。
+    - **name** （str， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回：表示等间隔划分结果的1-D Tensor，该Tensor的shape大小为 :math:`[num]` ，在mum为1的情况下，仅返回包含start元素值的Tensor。
 
-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当start或者stop的数据类型不是float32或者float64。
+    - ``TypeError`` - 当num的数据类型不是float32或者float64。
+    - ``TypeError`` - 当dtype的类型不是float32或者float64。
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/ones_cn.rst

@@ -5,21 +5,18 @@ ones
 
 .. py:function:: paddle.fluid.layers.ones(shape,dtype,force_cpu=False)
 
-
-
-
-**ones**
-
-该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。
+该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor。
 
 参数：
-    - **shape** (tuple|list) - 输出Tensor的形状。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
     - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。
-    - **force_cpu** (bool) – 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
+    - **force_cpu** (bool， 可选) – 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
 
 返回：值全为1的Tensor，数据类型和 ``dtype`` 定义的类型一致。
 
-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时， 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。
 
 **代码示例**：
 

doc/fluid/api_cn/layers_cn/zeros_cn.rst

@@ -5,21 +5,18 @@ zeros
 
 .. py:function:: paddle.fluid.layers.zeros(shape,dtype,force_cpu=False)
 
-
-
-
-**zeros**
-
-该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。
+该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor。
 
 参数：
-    - **shape** (tuple|list) - 输出Tensor的形状。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
     - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。
-    - **force_cpu** (bool) - 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
+    - **force_cpu** (bool， 可选) - 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
 
 返回：值全为0的Tensor，数据类型和 ``dtype`` 定义的类型一致。
 
-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时。 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。
 
 **代码示例**：
 

doc/fluid/api_cn/tensor_cn/eye_cn.rst

@@ -5,17 +5,16 @@ eye
 
 .. py:function:: paddle.tensor.eye(num_rows, num_columns=None, dtype=None, name=None)
 
-该OP用来构建二维张量(主对角线元素为1，其他元素为0)。
+该OP用来构建二维Tensor(主对角线元素为1，其他元素为0)。
 
 参数：
-    - **num_rows** (int) - 生成二维张量的行数，数据类型为非负int32。
-    - **num_columns** (int，可选) - 生成二维张量的列数，数据类型为非负int32。若为None，则默认等于num_rows。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str， 可选) - 返回张量的数据类型，可为float16，float32，float64， int32， int64。若为None, 则默认等于float32。
+    - **num_rows** (int) - 生成二维Tensor的行数，数据类型为非负int32。
+    - **num_columns** (int，可选) - 生成二维Tensor的列数，数据类型为非负int32。若为None，则默认等于num_rows。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str， 可选) - 返回Tensor的数据类型，可为float16，float32，float64， int32， int64。若为None, 则默认等于float32。
     - **name** （str， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
-返回：shape为 [num_rows, num_columns]的张量。
+返回： ``shape`` 为 [num_rows, num_columns]的Tensor。
 
-返回类型：Variable（Tensor），数据类型为dtype指定的类型。
 
 抛出异常：
     - ``TypeError``: - 如果 ``dtype`` 的类型不是float16， float32， float64， int32， int64其中之一。
@@ -26,8 +25,8 @@ eye
 .. code-block:: python
 
     import paddle
-    paddle.enable_imperative()
-    data = paddle.eye(3, dtype='int32') # paddle.eye 等价于 paddle.tensor.eye
+    paddle.enable_imperative()  # Now we are in imperative mode
+    data = paddle.eye(3, dtype='int32')
     # [[1 0 0]
     #  [0 1 0]
     #  [0 0 1]]

doc/fluid/api_cn/tensor_cn/full_cn.rst

@@ -5,27 +5,22 @@ full
 
 .. py:function:: paddle.full(shape, fill_value, dtype=None, name=None)
 
-:alias_main: paddle.full
-:alias: paddle.full,paddle.tensor.full,paddle.tensor.creation.full
-:update_api: paddle.fluid.layers.fill_constant
 
 
-
-该OP创建形状大小为shape并且数据类型为dtype的张量，其中元素值均为 ``fill_value``。
+该OP创建形状大小为shape并且数据类型为dtype的Tensor，其中元素值均为 ``fill_value``。
 
 参数：
-    - **shape** (list|tuple|Variable) – 指定创建张量的形状(shape), 数据类型为int32 或者int64。
-    - **fill_value** (bool|float|int|Variable) - 用于初始化输出张量的常量数据的值。注意：该参数不可超过输出变量数据类型的表示范围。
+    - **shape** (list|tuple|Tensor) – 指定创建Tensor的形状(shape), 数据类型为int32 或者int64。
+    - **fill_value** (bool|float|int|Tensor) - 用于初始化输出Tensor的常量数据的值。注意：该参数不可超过输出变量数据类型的表示范围。
     - **dtype** （np.dtype|core.VarDesc.VarType|str， 可选）- 输出变量的数据类型。若为None，则输出变量的数据类型和输入变量相同，默认值为None。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
     
 返回：返回一个存储结果的Tensor，数据类型和dtype相同。
 
-返回类型：Variable
 
 抛出异常：
     - ``TypeError``: - 如果 ``dtype`` 的类型不是bool, float16, float32, float64, int32, int64其中之一。
-    - ``TypeError``: - 如果 ``shape`` 的类型不是list或tuple或Variable。
+    - ``TypeError``: - 如果 ``shape`` 的类型不是list或tuple或Tensor。当 ``shape`` 是Tensor的时候，其数据类型不是int32或者int64时。
 
 **代码示例**：
 
@@ -38,18 +33,18 @@ full
     #[[0]
     # [0]]
 
-    # attr shape is a list which contains Variable Tensor.
+    # attr shape is a list which contains Tensor.
     positive_3 = paddle.fill_constant([1], "int32", 2)
     data3 = paddle.full(shape=[1, positive_2], dtype='float32', fill_value=1.5)
     # [[1.5 1.5]]
 
-    # attr shape is an Variable Tensor.
+    # attr shape is a Tensor.
     shape = paddle.fill_constant([2], "int32", 2)
     data4 = paddle.full(shape=shape, dtype='bool', fill_value=True) 
     # [[True True] 
     #  [True True]]
     
-    # attr fill_value is an Variable Tensor.
+    # attr fill_value is a Tensor.
     val = paddle.fill_constant([1], "float32", 2.0)
     data5 = paddle.full(shape=[2,1], fill_value=val, dtype='float32') i
     # [[2.0] 

doc/fluid/api_cn/tensor_cn/full_like_cn.rst

@@ -5,24 +5,20 @@ full_like
 
 .. py:function:: paddle.full_like(x, fill_value, dtype=None, name=None)
 
-:alias_main: paddle.full_like
-:alias: paddle.full_like,paddle.tensor.full_like,paddle.tensor.creation.full_like
 
-该OP创建一个和x具有相同的形状和数据类型的张量，其中元素值均为 ``fill_value``。
+该OP创建一个和 ``x`` 具有相同的形状并且数据类型为 ``dtype`` 的Tensor，其中元素值均为 ``fill_value`` , 当 ``dtype`` 为None的时候，Tensor数据类型和输入 ``x`` 相同。
 
 参数：
-    - **x** (Variable) – 输入张量, 输出张量和x具有相同的形状，x的数据类型可以是bool，float16，float32，float64，int32，int64。
+    - **x** (Tensor) – 输入Tensor, 输出Tensor和x具有相同的形状，x的数据类型可以是bool，float16，float32，float64，int32，int64。
     - **fill_value** (bool|float|int) - 用于初始化输出张量的常量数据的值。注意：该参数不可超过输出变量数据类型的表示范围。
     - **dtype** （np.dtype|core.VarDesc.VarType|str， 可选）- 输出变量的数据类型。若参数为None，则输出变量的数据类型和输入变量相同，默认值为None。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
     
 返回：返回一个存储结果的Tensor，数据类型和dtype相同。
 
-返回类型：Variable
-
 抛出异常：
-    - ``TypeError``: - 当dtype不是bool、float16、float32、float64、int32、int64其中之一。
-    - ``TypeError``: - 如果 ``shape`` 的类型不是list或tuple或Varibable。
+    - ``TypeError``: - 当 ``x`` 的数据类型不是bool、float16、float32、float64、int32、int64其中之一。
+    - ``TypeError``: - 当 ``dtype`` 不是bool、float16、float32、float64、int32、int64或者None其中之一。
 
     **代码示例**：
 

doc/fluid/api_cn/tensor_cn/index_select_cn.rst

@@ -5,25 +5,22 @@ index_select
 
 .. py:function:: paddle.index_select(x, index, axis=0, name=None)
 
-:alias_main: paddle.index_select
-:alias: paddle.index_select,paddle.tensor.index_select,paddle.tensor.search.index_select
 
 
-
-该OP沿着指定维度 ``axis`` 对输入 ``input`` 进行索引，取 ``index`` 中指定的相应项，然后返回到一个新的张量。这里 ``index`` 是一个 ``1-D`` 张量。除 ``axis`` 维外，返回的张量其余维度大小同输入 ``input`` ， ``axis`` 维大小等于 ``index`` 的大小。
+该OP沿着指定轴 ``axis`` 对输入 ``x`` 进行索引，取 ``index`` 中指定的相应项，创建并返回到一个新的Tensor。这里 ``index`` 是一个 ``1-D`` Tensor。除 ``axis`` 轴外，返回的Tensor其余维度大小和输入 ``x``相等 ， ``axis`` 维度的大小等于 ``index`` 的大小。
         
 **参数**：
-    - **x** （Variable）– 输入张量。x的数据类型可以是float32，float64，int32，int64。
-    - **index** （Variable）– 包含索引下标的一维张量。
-    - **axis**    (int, optional) – 索引轴，若未指定，则默认选取第0维。
+    - **x** （Tensor）– 输入Tensor。 ``x`` 的数据类型可以是float32，float64，int32，int64。
+    - **index** （Tensor）– 包含索引下标的一维Tensor。
+    - **axis**    (int, 可选) – 索引轴，若未指定，则默认选取第0维。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 **返回**：
-    -**Variable**: 数据类型同输入。
+    -**Tensor**: 返回一个数据类型同输入的Tensor。
      
 抛出异常：
-    - ``TypeError`` - 当x或者index的类型不是Variable。
-    - ``TypeError`` - 当x的数据类型不是float32、float64、int32、int64其中之一或者index的数据类型不是int32、int64其中之一。
+    - ``TypeError`` - 当 ``x`` 或者 ``index`` 的类型不是Tensor。
+    - ``TypeError`` - 当 ``x`` 的数据类型不是float32、float64、int32、int64其中之一或者 ``index`` 的数据类型不是int32、int64其中之一。
 
 
 **代码示例**：

doc/fluid/api_cn/tensor_cn/linspace_cn.rst

@@ -6,20 +6,19 @@ linspace
 .. py:function:: paddle.linspace(start, stop, num, dtype=None, name=None)
 
 :alias_main: paddle.linspace
-:alias: paddle.linspace,paddle.tensor.linspace,paddle.tensor.creation.linspace
-:update_api: paddle.fluid.layers.linspace
+:alias: paddle.tensor.linspace, paddle.tensor.creation.linspace
 
 
 
-该OP在给定区间内返回固定数目的均匀间隔的值。
+该OP返回一个Tensor，Tensor的值为在区间start和stop上均匀间隔的num个值，输出Tensor的长度为num。
 
 **注意：该OP不进行梯度计算**
  
 参数：
-    - **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** (np.dtype|core.VarDesc.VarType|str，可选) – 输出Tensor的数据类型，可以是‘float32’或者是‘float64’。如果dtype为None，默认类型为float32。
+    - **start** (float|Tensor) – ``start`` 是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **stop** (float|Tensor) – ``end`` 是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) – 输出Tensor的数据类型，可以是float32或者是float64。如果dtype为None，默认类型为float32。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回：输出结果的数据类型是float32或float64，表示等间隔划分结果的1-D Tensor，该Tensor的shape大小为 :math:`[num]` ，在mum为1的情况下，仅返回包含start元素值的Tensor。

doc/fluid/api_cn/tensor_cn/ones_cn.rst

@@ -5,27 +5,21 @@ ones
 
 .. py:function:: paddle.ones(shape, dtype=None)
 
-:alias_main: paddle.ones
-:alias: paddle.ones,paddle.tensor.ones,paddle.tensor.creation.ones
-:update_api: paddle.fluid.layers.ones
-
-
 
 
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor。
 
 参数：
-    - **shape** (tuple|list|Variable) - 输出Tensor的形状，数据类型为int32或者int64。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str， 可选) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。如果dtype为None，默认数据类型为float32。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str， 可选) - 输出Tensor的数据类型，数据类型必须为bool、 float16、float32、float64、int32或int64。如果 ``dtype`` 为None，默认数据类型为float32。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回：值全为1的Tensor，数据类型和 ``dtype`` 定义的类型一致。
 
-返回类型：Variable
 
 抛出异常：
-    - ``TypeError`` - 当dtype不是float16、float32、float64、int32或int64中的一个的时候
-    - ``TypeError`` - 当shape 不是tuple、list、或者Variable的时候。
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor的时， 当 ``shape`` 为Tensor时，其数据类型不是int32或者int64。
 
 **代码示例**：
 

doc/fluid/api_cn/tensor_cn/zeros_cn.rst

@@ -3,31 +3,40 @@
 zeros
 -------------------------------
 
-.. py:function:: paddle.zeros(shape, dtype, out=None, device=None)
-
-:alias_main: paddle.zeros
-:alias: paddle.zeros,paddle.tensor.zeros,paddle.tensor.creation.zeros
-:update_api: paddle.fluid.layers.zeros
+.. py:function:: paddle.zeros(shape, dtype=None, name=None)
 
 
 
 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor。
 
 参数：
-    - **shape** (tuple|list) - 输出Tensor的形状。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。
-    - **out** (Variable, 可选) – 指定存储运算结果的Tensor。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
-    - **device** (str，可选) – 选择在哪个设备运行该操作，可选值包括None，'cpu'和'gpu'。如果 ``device``  为None，则将选择运行Paddle程序的设备，默认为None。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为bool、float16、float32、float64、int32或int64。
 
 返回：值全为0的Tensor，数据类型和 ``dtype`` 定义的类型一致。
 
-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时， 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。
 
 **代码示例**：
 
 .. code-block:: python
 
     import paddle
-    data = paddle.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]]
-    data = paddle.zeros(shape=[2, 2], dtype='float32', device='cpu') # [[0., 0.], [0., 0.]]
+    paddle.enable_imperative()  # Now we are in imperative mode
+    data = paddle.zeros(shape=[3, 2], dtype='float32') 
+    # [[0. 0.]
+    #  [0. 0.]
+    #  [0. 0.]]
+    
+    data = paddle.zeros(shape=[2, 2]) 
+    # [[0. 0.]
+    #  [0. 0.]]
+    
+    # shape is a Tensor
+    shape = paddle.fill_constant(shape=[2], dtype='int32', value=2)
+    data3 = paddle.ones(shape=shape, dtype='int32') 
+    # [[0 0]
+    #  [0 0]]