mdify roll, meshgrid, flip, trace cn doc according to 2.0 standard test=develop (#2277)

doc/fluid/api_cn/tensor_cn/flip_cn.rst

@@ -3,53 +3,41 @@
 flip
 -------------------------------
 
-.. py:function:: paddle.flip(input, dims, name=None):
+.. py:function:: paddle.flip(x, axis, name=None):
 
 :alias_main: paddle.flip
-:alias: paddle.flip,paddle.tensor.flip,paddle.tensor.manipulation.flip
+:alias: paddle.flip, paddle.tensor.flip, paddle.tensor.manipulation.flip
 
 
 
 该OP沿指定轴反转n维tensor.
 
 参数：
-    - **input** (Variable) - 输入Tensor。维度为多维，数据类型为bool, int32, int64, float32或float64。
-    - **dims** (list) - 需要翻转的轴。当 ``dims[i] < 0`` 时，实际的计算维度为 rank(input) + dims[i]，其中i为dims的索引。
+    - **x** (Variable) - 输入张量。维度为多维，数据类型为bool, int32, int64, float32或float64。
+    - **axis** (list) - 需要翻转的轴。当 ``axis[i] < 0`` 时，实际的计算维度为 ndim(x) + axis[i]，其中i为axis的索引。
     - **name** (str|None) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。默认值为None。
 
-返回：在指定dims上翻转后的Tensor，与输入input数据类型相同。
+返回：在指定axis上翻转后的张量，与输入x数据类型相同。
 
-返回类型：Variable，与输入input数据类型相同。
+返回类型：Variable，与输入x数据类型相同。
 
 抛出异常：
-    - ``TypeError`` - 当输出 ``out`` 和输入 ``input`` 数据类型不一致时候。
-    - ``ValueError`` - 当参数  ``dims`` 不合法时。
+    - ``TypeError`` - 当输出 ``out`` 和输入 ``x`` 数据类型不一致时候。
+    - ``ValueError`` - 当参数  ``axis`` 不合法时。
 
 **代码示例1**：
 
 .. code-block:: python
 
     import paddle
-    import paddle.fluid as fluid
     import numpy as np
-    input = fluid.data(name="x", shape=[-1, 2, 2], dtype='float32')
-    output = paddle.flip(input, dims=[0, 1])
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-    img = np.arange(12).reshape((3,2,2)).astype(np.float32)
-    res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output])
-    print(res) # [[[10,11][8, 9]],[[6, 7],[4, 5]] [[2, 3],[0, 1]]]
 
-**代码示例2**：
-
-.. code-block:: python
-
-    import paddle
-    import paddle.fluid as fluid
-    import numpy as np
-    img = np.arange(12).reshape((3,2,2)).astype(np.float32)
-    with fluid.dygraph.guard():
-      inputs = fluid.dygraph.to_variable(img)
-      ret = paddle.flip(inputs, [0, 1])
-      print(ret.numpy()) # [[[10,11][8, 9]],[[6, 7],[4, 5]] [[2, 3],[0, 1]]]
+    paddle.enable_imperative()
+    
+    image_shape=(3, 2, 2)
+    x = np.arange(image_shape[0] * image_shape[1] * image_shape[2]).reshape(image_shape)
+    x = x.astype('float32')
+    img = paddle.imperative.to_variable(x)
+    out = paddle.flip(img, [0,1])
+    print(out) # [[[10,11][8, 9]],[[6, 7],[4, 5]] [[2, 3],[0, 1]]]
 

doc/fluid/api_cn/tensor_cn/meshgrid_cn.rst

@@ -4,58 +4,40 @@
 meshgrid
 -------------------------------
 
-.. py:function:: paddle.tensor.meshgrid(input, name=None)
+.. py:function:: paddle.tensor.meshgrid(*args, **kargs)
 
 :alias_main: paddle.meshgrid
-:alias: paddle.meshgrid,paddle.tensor.meshgrid,paddle.tensor.creation.meshgrid
+:alias: paddle.meshgrid, paddle.tensor.meshgrid, paddle.tensor.creation.meshgrid
 
 
 
-该OP的输入是tensor list, 包含 k 个一维Tensor，对每个Tensor做扩充操作，输出 k 个 k 维tensor。
+该OP的输入是张量或者包含张量的列表, 包含 k 个一维张量，对每个张量做扩充操作，输出 k 个 k 维张量。
 
 参数：
-         - **input** （Variable）- 输入变量为 k 个一维Tensor，形状分别为(N1,), (N2,), ..., (Nk, )。支持数据类型为float32，float64，int32，int64。
-         - **name** （str， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+         - \* **args** （Variable|Variable数组）- 输入变量为 k 个一维张量，形状分别为(N1,), (N2,), ..., (Nk, )。支持数据类型为float32，float64，int32，int64。
+         - ** **kargs** （可选）- 目前只接受name参数（str），具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回： 
-k 个 k 维Tensor，每个Tensor的形状均为(N1, N2, ..., Nk)。
+k 个 k 维张量，每个张量的形状均为(N1, N2, ..., Nk)。
 
 返回类型：  变量（Variable）
 
 **代码示例**
 
-..  code-block:: python
-
-    #静态图示例
-    import paddle
-    import paddle.fluid as fluid
-    import numpy as np
-    x = fluid.data(name='x', shape=[100], dtype='int32')
-    y = fluid.data(name='y', shape=[200], dtype='int32')
-    input_1 = np.random.randint(0, 100, [100, ]).astype('int32')
-    input_2 = np.random.randint(0, 100, [200, ]).astype('int32')
-    exe = fluid.Executor(place=fluid.CPUPlace())
-    grid_x, grid_y = paddle.tensor.meshgrid([x, y])
-    res_1, res_2 = exe.run(fluid.default_main_program(),
-                            feed={'x': input_1,
-                                  'y': input_2},
-                            fetch_list=[grid_x, grid_y])
-     
-    #the shape of res_1 is (100, 200)
-    #the shape of res_2 is (100, 200)
 
 
 ..  code-block:: python
 
     #动态图示例
     import paddle
-    import paddle.fluid as fluid
     import numpy as np
+    
+    paddle.enable_imperative()
+
     input_3 = np.random.randint(0, 100, [100, ]).astype('int32')
     input_4 = np.random.randint(0, 100, [200, ]).astype('int32')
-    with fluid.dygraph.guard():
-        tensor_3 = fluid.dygraph.to_variable(input_3)
-        tensor_4 = fluid.dygraph.to_variable(input_4)
-        grid_x, grid_y = paddle.tensor.meshgrid([tensor_3, tensor_4])
+    tensor_3 = paddle.imperative.to_variable(input_3)
+    tensor_4 = paddle.imperative.to_variable(input_4)
+    grid_x, grid_y = paddle.tensor.meshgrid(tensor_3, tensor_4)
     #the shape of grid_x is (100, 200)
     #the shape of grid_y is (100, 200)    

doc/fluid/api_cn/tensor_cn/roll_cn.rst

@@ -3,19 +3,20 @@
 roll
 -------------------------------
 
-.. py:function:: paddle.roll(input, shifts, dims=None):
+.. py:function:: paddle.roll(x, shifts, axis=None, name=None):
 
 :alias_main: paddle.roll
-:alias: paddle.roll,paddle.tensor.roll,paddle.tensor.manipulation.roll
+:alias: paddle.roll, paddle.tensor.roll, paddle.tensor.manipulation.roll
 
 
 
-该OP沿着指定维度对输入 ``input`` 进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入。如果 ``dims`` 为 ``None`` ，则输入在被循环滚动之前，会先展平成 ``1-D Tensor`` ，滚动操作完成后恢复成原来的形状。
+该OP沿着指定维度 ``axis`` 对输入 ``x`` 进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入。如果 ``axis`` 为 ``None`` ，则输入在被循环滚动之前，会先展平成 ``1-D Tensor`` ，滚动操作完成后恢复成原来的形状。
 
 **参数**：
-    - **input** （Variable）– 输入张量。
-    - **shifts** (int|list|tuple) - 滚动位移。如果 ``shifts`` 是一个元组或者列表，则 ``dims`` 必须是相同大小的元组或者列表，输入张量将依次沿着每个维度滚动相应的数值。
-    - **dim**    (int|list|tuple, optinal) – 滚动轴。
+    - **x** （Variable）– 输入张量。
+    - **shifts** (int|list|tuple) - 滚动位移。如果 ``shifts`` 是一个元组或者列表，则 ``axis`` 必须是相同大小的元组或者列表，输入张量将依次沿着每个维度滚动相应的数值。
+    - **axis**    (int|list|tuple, optinal) – 滚动轴。
+    - **name** (str，可选)- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 **返回**：
     - **Variable**，数据类型同输入。
@@ -26,22 +27,21 @@ roll
 
         import numpy as np
         import paddle
-        import paddle.fluid as fluid
 
         data = np.array([[1.0, 2.0, 3.0],
                             [4.0, 5.0, 6.0],
                             [7.0, 8.0, 9.0]])
-        with fluid.dygraph.guard():
-            x = fluid.dygraph.to_variable(data)
-            out_z1 = paddle.roll(x, shifts=1)
-            print(out_z1.numpy())
-            #[[9. 1. 2.]
-            # [3. 4. 5.]
-            # [6. 7. 8.]]
-            out_z2 = paddle.roll(x, shifts=1, dims=0)
-            print(out_z2.numpy())
-            #[[7. 8. 9.]
-            # [1. 2. 3.]
-            # [4. 5. 6.]]
+        paddle.enable_imperative()
+        x = paddle.imperative.to_variable(data)
+        out_z1 = paddle.roll(x, shifts=1)
+        print(out_z1.numpy())
+        #[[9. 1. 2.]
+        # [3. 4. 5.]
+        # [6. 7. 8.]]
+        out_z2 = paddle.roll(x, shifts=1, axis=0)
+        print(out_z2.numpy())
+        #[[7. 8. 9.]
+        # [1. 2. 3.]
+        # [4. 5. 6.]]
 
 

doc/fluid/api_cn/tensor_cn/trace_cn.rst

@@ -3,10 +3,10 @@
 trace
 -------------------------------
 
-.. py:function:: paddle.trace(input, offset=0, dim1=0, dim2=1)
+.. py:function:: paddle.trace(x, offset=0, axis1=0, axis2=1, name=None)
 
 :alias_main: paddle.trace
-:alias: paddle.trace,paddle.tensor.trace,paddle.tensor.math.trace
+:alias: paddle.trace, paddle.tensor.trace, paddle.tensor.math.trace
 
 
 
@@ -14,7 +14,7 @@ trace
 
 如果输入是 2D Tensor，则返回对角线元素之和。 
 
-如果输入的维度大于 2D，则返回一个由对角线元素之和组成的数组，其中对角线从由 dim1 和 dim2 指定的二维平面中获得。默认由输入的前两维组成获得对角线的 2D 平面。
+如果输入的维度大于 2D，则返回一个由对角线元素之和组成的数组，其中对角线从由 axis1 和 axis2 指定的二维平面中获得。默认由输入的前两维组成获得对角线的 2D 平面。
 
 参数 ``offset`` 确定从指定的二维平面中获取对角线的位置：
 
@@ -23,10 +23,11 @@ trace
     - 如果 offset < 0，则取主对角线左下的对角线。
 
 参数：
-    - **input** （Variable）- 输入变量，至少为 2D 数组，支持数据类型为 float32，float64，int32，int64。
+    - **x** （Variable）- 输入张量，至少为 2D 数组，支持数据类型为 float32，float64，int32，int64。
     - **offset** （int ，可选）- 从指定的二维平面中获取对角线的位置，默认值为 0，既主对角线。
-    - **dim1** （int ， 可选）- 获取对角线的二维平面的第一维，默认值为 0。
-    - **dim2** （int ， 可选）- 获取对角线的二维平面的第二维，默认值为 1。
+    - **axis1** （int ， 可选）- 获取对角线的二维平面的第一维，默认值为 0。
+    - **axis2** （int ， 可选）- 获取对角线的二维平面的第二维，默认值为 1。
+    - **name** (str，可选)- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 
 返回： 指定二维平面的对角线元素之和。数据类型和输入数据类型一致。
 
@@ -36,18 +37,17 @@ trace
 
 ..  code-block:: python
 
-    import paddle.tensor as tensor
-    import paddle.fluid.dygraph as dg
+    import paddle
     import numpy as np
-            
+    
     case1 = np.random.randn(2, 3).astype('float32')
     case2 = np.random.randn(3, 10, 10).astype('float32')
     case3 = np.random.randn(3, 10, 5, 10).astype('float32')
-            
-    with dg.guard():
-        case1 = dg.to_variable(case1)
-        case2 = dg.to_variable(case2)
-        case3 = dg.to_variable(case3)
-        data1 = tensor.trace(case1) # data1.shape = [1]
-        data2 = tensor.trace(case2, offset=1, dim1=1, dim2=2) # data2.shape = [3]
-        data3 = tensor.trace(case3, offset=-3, dim1=1, dim2=-1) # data2.shape = [3, 5]
+    
+    paddle.enable_imperative()
+    case1 = paddle.imperative.to_variable(case1)
+    case2 = paddle.imperative.to_variable(case2)
+    case3 = paddle.imperative.to_variable(case3)
+    data1 = paddle.trace(case1) # data1.shape = [1]
+    data2 = paddle.trace(case2, offset=1, axis1=1, axis2=2) # data2.shape = [3]
+    data3 = paddle.trace(case3, offset=-3, axis1=1, axis2=-1) # data2.shape = [3, 5]