add Chinese doc in ops(sum, zeros, zeros_like, ones, ones_like, mm,...

add Chinese doc in ops(sum, zeros, zeros_like, ones, ones_like, mm, elemenwise_equal, elememtwise_sum, sort, argmax)

add Chinese doc in ops(sum, zeros, zeros_like, ones, ones_like, mm, elemenwise_equal, elememtwise_sum, sort, argmax)

doc/fluid/api_cn/tensor_cn/argmax_cn.rst

+.. _cn_api_tensor_argmax:
+
 argmax
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.argmax(input, axis=None, dtype=None, out=None, keepdims=False, name=None)
+
+
+该OP沿 ``axis`` 计算输入 ``input`` 的最大元素的索引。
+
+参数：
+    - **input** (Variable) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int8、int16、int32、int64。
+    - **axis** (int，可选) - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``input`` 的Rank， ``axis`` -R与绝对值相同的R等价。默认值为0。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str)- 输出Tensor的数据类型，可选值为int32，int64，默认值为None，将返回int64类型的结果。
+    - **out** (Variable, 可选) – 指定存储运算结果的Tensor。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
+    - **keepdims** （bool，可选）- 是否保留进行max index操作的维度，默认值为False。
+    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回： ``Tensor`` ，数据类型int64
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+    import numpy as np
+
+    in1 = np.array([[[5,8,9,5],
+                     [0,0,1,7],
+                     [6,9,2,4]],
+                    [[5,2,4,2],
+                     [4,7,7,9],
+                     [1,7,0,6]]])
+    with fluid.dygraph.guard():
+        x = fluid.dygraph.to_variable(in1)
+        out1 = paddle.argmax(input=x, axis=-1)
+        out2 = paddle.argmax(input=x, axis=0)
+        out3 = paddle.argmax(input=x, axis=1)
+        out4 = paddle.argmax(input=x, axis=2)
+        out5 = paddle.argmax(input=x, axis=2, keepdims=True)
+        print(out1.numpy())
+        # [[2 3 1]
+        #  [0 3 1]]
+        print(out2.numpy())
+        # [[0 0 0 0]
+        #  [1 1 1 1]
+        #  [0 0 0 1]]
+        print(out3.numpy())
+        # [[2 2 0 1]
+        #  [0 1 1 1]]
+        print(out4.numpy())
+        # [[2 3 1]
+        #  [0 3 1]]
+        print(out5.numpy())
+        #array([[[2],
+        #        [3],
+        #        [1]],
+        #       [[0],
+        #        [3],
+        #        [1]]])

doc/fluid/api_cn/tensor_cn/elementwise_equal_cn.rst

-elementwise
+.. _cn_api_tensor_elementwise_equal:
+
+elementwise_equal
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.elementwise_equal(x, y, name=None)
+
+该OP返回 :math:`x==y` 逐元素比较x和y是否相等。
+
+参数：
+    - **x** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。
+    - **y** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。
+
+返回类型：变量（Variable）
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+    import numpy as np
+    
+    label = fluid.layers.assign(np.array([3, 3], dtype="int32"))
+    limit = fluid.layers.assign(np.array([3, 2], dtype="int32"))
+    out1 = paddle.elementwise_equal(x=label, y=limit) #out1=[True, False]

doc/fluid/api_cn/tensor_cn/elementwise_sum_cn.rst

-elementwise
+.. _cn_api_tensor_elementwise_sum:
+
+elementwise_sum
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.elementwise_sum(inputs, name=None)
+
+该OP用于对输入的一至多个Tensor或LoDTensor求和。如果输入的是LoDTensor，输出仅与第一个输入共享LoD信息（序列信息）。
+
+例1：
+::
+    输入：
+        input.shape = [2, 3]
+        input = [[1, 2, 3],
+              [4, 5, 6]]
+
+    输出：
+        output.shape = [2, 3]
+        output = [[1, 2, 3],
+                [4, 5, 6]]
+
+例2：
+::
+    输入：
+    第一个输入：
+            input1.shape = [2, 3]
+            input1 = [[1, 2, 3],
+                  [4, 5, 6]]
+
+    第二个输入：
+            input2.shape = [2, 3]
+            input2 = [[7, 8, 9],
+                  [10, 11, 12]]
+
+    输出：
+        output.shape = [2, 3]
+        output = [[8, 10, 12],
+              [14, 16, 18]]
+
+参数：
+    - **inputs** (Variable|list(Variable)) - 输入的一至多个Variable。如果输入了多个Variable，则不同Variable间的shape和数据类型应保持一致。Variable为多维Tensor或LoDTensor，数据类型支持：float32，float64，int32，int64。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：对输入 ``inputs`` 中的Variable求和后的结果，shape和数据类型与 ``inputs`` 一致。
+
+返回类型：Variable
+
+
+**代码示例：**
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+    input0 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=5)
+    input1 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=3)
+    sum = paddle.elementwise_sum([input0, input1])
+
+    #用户可以通过executor打印出求和的结果
+    out = fluid.layers.Print(sum, message="the sum of input0 and input1: ")
+    exe = fluid.Executor(fluid.CPUPlace())
+    exe.run(fluid.default_main_program())
+
+    #打印出的数据为：
+    1570701754  the sum of input0 and input1:   The place is:CPUPlace
+    Tensor[elementwise_sum_0.tmp_0]
+        shape: [2,3,]
+        dtype: l
+        data: 8,8,8,8,8,8,
+
+    #输出了shape为[2,3]的Tensor，与输入的shape一致
+    #dtype为对应C++数据类型，在不同环境下可能显示值不同，但本质相同
+    #例如：如果Tensor中数据类型是int64，则对应的C++数据类型为int64_t，所以dtype值为typeid(int64_t).name()，
+    #      其在MacOS下为'x'，linux下为'l'，Windows下为'__int64'，都表示64位整型变量
+

doc/fluid/api_cn/tensor_cn/mm_cn.rst

+.. _cn_api_tensor_mm:
+
 mm
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.mm(input, mat2, out=None, name=None)
+
+用于两个输入矩阵的相乘。
+
+两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。
+
+如果原始 Tensor input 或 mat2 的秩为 1 且未转置，则矩阵相乘后的前置或附加维度 1 将移除。
+
+参数：
+    - **input** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor。
+    - **mat2** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor。
+    - **out** (Variable, 可选) – 指定存储运算结果的Tensor。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：
+    - Variable (Tensor / LoDTensor)，矩阵相乘后的结果。
+
+返回类型：
+    - Variable（变量）。
+
+::
+
+    * 例 1:
+
+    input: [B, ..., M, K], mat2: [B, ..., K, N]
+    out: [B, ..., M, N]
+
+    * 例 2:
+
+    input: [B, M, K], mat2: [B, K, N]
+    out: [B, M, N]
+
+    * 例 3:
+
+    input: [B, M, K], mat2: [K, N]
+    out: [B, M, N]
+
+    * 例 4:
+
+    input: [M, K], mat2: [K, N]
+    out: [M, N]
+
+    * 例 5:
+
+    input: [B, M, K], mat2: [K]
+    out: [B, M]
+
+    * 例 6:
+
+    input: [K], mat2: [K]
+    out: [1]
+
+    * 例 7:
+
+    input: [M], mat2: [N]
+    out: [M, N]
+
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+
+    input = fluid.data(name='input', shape=[2, 3], dtype='float32')
+    mat2 = fluid.data(name='mat2', shape=[3, 2], dtype='float32')
+    out = paddle.mm(input, mat2) # out shape is [2, 2]
+

doc/fluid/api_cn/tensor_cn/ones_cn.rst

+.. _cn_api_tensor_ones:
+
 ones
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.ones(shape, dtype, out=None, device=None)
+
+
+该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的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。
+
+返回：值全为1的Tensor，数据类型和 ``dtype`` 定义的类型一致。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle
+    data = paddle.ones(shape=[3, 2], dtype='float32') # [[1., 1.], [1., 1.], [1., 1.]]
+    data = paddle.ones(shape=[2, 2], dtype='float32', device='cpu') # [[1., 1.], [1., 0.]]
+

doc/fluid/api_cn/tensor_cn/ones_like_cn.rst

-ones
+.. _cn_api_tensor_ones_like:
+
+ones_like
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.ones_like(input, dtype=None, device=None, name=None)
+
+
+该OP创建一个和input具有相同的形状和数据类型的全1Tensor。
+
+参数：
+    - **input** (Variable) – 指定输入为一个多维的Tensor，数据类型可以是bool，float32，float64，int32，int64。
+    - **dtype** （np.dtype|core.VarDesc.VarType|str， 可选）- 输出变量的数据类型。若参数为空，则输出变量的数据类型和输入变量相同，默认值为None。
+    - **device** (str，可选) – 选择在哪个设备运行该操作，可选值包括None，'cpu'和'gpu'。如果 ``device`` 为None，则将选择运行Paddle程序的设备，默认为None。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+    
+返回：返回一个存储结果的Tensor。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+    x = fluid.data(name='x', dtype='float32', shape=[3])
+    data = paddle.ones_like(x) # data=[1.0, 1.0, 1.0]
+    data1 = paddle.ones_like(input=x, device="gpu") # data1=[1.0, 1.0. 1.0]

doc/fluid/api_cn/tensor_cn/sort_cn.rst

+.. _cn_api_tensor_sort:
+
 sort
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.sort(input, axis=-1, descending=False, out=None, name=None)
+
+对输入变量沿给定轴进行排序，输出排序好的数据和相应的索引，其维度和输入相同。**默认升序排列，如果需要降序排列设置** ``descending=True`` 。
+
+
+参数：
+    - **input** (Variable) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。
+    - **axis** (int，可选) - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``x`` 的Rank， ``axis`` 为负时与 ``axis`` +R 等价。默认值为0。
+    - **descending** (bool，可选) - 指定算法排序的方向。如果设置为True，算法按照降序排序。如果设置为False或者不设置，按照升序排序。默认值为False。
+    - **out** (Variable, 可选) – 指定存储运算结果的Tensor（与 ``input`` 维度相同、数据类型相同）。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
+    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：一组已排序的输出（与 ``input`` 维度相同、数据类型相同）和索引（数据类型为int64）。
+
+返回类型：tuple[Variable]
+
+**代码示例**：
+
+.. code-block:: python
+
+  import paddle
+  import paddle.fluid as fluid
+  import numpy as np
+
+  in1 = np.array([[[5,8,9,5],
+                   [0,0,1,7],
+                   [6,9,2,4]],
+                  [[5,2,4,2],
+                   [4,7,7,9],
+                   [1,7,0,6]]]).astype(np.float32)
+  with fluid.dygraph.guard():
+      x = fluid.dygraph.to_variable(in1)
+      out1 = paddle.sort(input=x, axis=-1) # same as axis==2
+      out2 = paddle.sort(input=x, axis=0)
+      out3 = paddle.sort(input=x, axis=1)
+      print(out1[0].numpy())
+      # [[[5. 5. 8. 9.]
+      #   [0. 0. 1. 7.]
+      #   [2. 4. 6. 9.]]
+      #  [[2. 2. 4. 5.]
+      #   [4. 7. 7. 9.]
+      #   [0. 1. 6. 7.]]]
+      print(out1[1].numpy())
+      # [[[0 3 1 2]
+      #   [0 1 2 3]
+      #   [2 3 0 1]]
+      #  [[1 3 2 0]
+      #   [0 1 2 3]
+      #   [2 0 3 1]]]
+      print(out2[0].numpy())
+      # [[[5. 2. 4. 2.]
+      #   [0. 0. 1. 7.]
+      #   [1. 7. 0. 4.]]
+      #  [[5. 8. 9. 5.]
+      #   [4. 7. 7. 9.]
+      #   [6. 9. 2. 6.]]]
+      print(out3[0].numpy())
+      # [[[0. 0. 1. 4.]
+      #   [5. 8. 2. 5.]
+      #   [6. 9. 9. 7.]]
+      #  [[1. 2. 0. 2.]
+      #   [4. 7. 4. 6.]
+      #   [5. 7. 7. 9.]]]
+

doc/fluid/api_cn/tensor_cn/sum_cn.rst

+.. _cn_api_tensor_sum:
+
 sum
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.sum(input, dim=None, dtype=None, keep_dim=False, name=None)
+
+该OP是对指定维度上的Tensor元素进行求和运算，并输出相应的计算结果。
+
+参数：
+    - **input** （Variable）- 输入变量为多维Tensor或LoDTensor，支持数据类型为float32，float64，int32，int64。
+    - **dim** （list | int ，可选）- 求和运算的维度。如果为None，则计算所有元素的和并返回包含单个元素的Tensor变量，否则必须在  :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将变为 :math:`rank+dim[i]` ，默认值为None。
+    - **dtype** （str ， 可选）- 输出变量的数据类型。若参数为空，则输出变量的数据类型和输入变量相同，默认值为None。
+    - **keep_dim** （bool）- 是否在输出Tensor中保留减小的维度。如 keep_dim 为true，否则结果张量的维度将比输入张量小，默认值为False。
+    - **name** （str ， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：  在指定dim上进行求和运算的Tensor，数据类型和输入数据类型一致。
+
+返回类型：  变量（Variable）
+
+**代码示例**
+
+..  code-block:: python
+
+      import paddle
+      import paddle.fluid as fluid
+      # x是一个Tensor，元素如下:
+      #    [[0.2, 0.3, 0.5, 0.9]
+      #     [0.1, 0.2, 0.6, 0.7]]
+      # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
+      x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+      out1 = paddle.sum(x)  # [3.5]
+      out2 = paddle.sum(x, dim=0)  # [0.3, 0.5, 1.1, 1.6]
+      out3 = paddle.sum(x, dim=-1)  # [1.9, 1.6]
+      out4 = paddle.sum(x, dim=1, keep_dim=True)  # [[1.9], [1.6]]
+
+      # y 是一个shape为[2, 2, 2]的Tensor元素如下:
+      #      [[[1, 2], [3, 4]],
+      #      [[5, 6], [7, 8]]]
+      # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
+      y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+      out5 = paddle.sum(y, dim=[1, 2]) # [10, 26]
+      out6 = paddle.sum(y, dim=[0, 1]) # [16, 20]

doc/fluid/api_cn/tensor_cn/zeros_cn.rst

+.. _cn_api_tensor_zeros:
+
 zeros
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.zeros(shape, dtype, out=None, device=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。
+
+返回：值全为0的Tensor，数据类型和 ``dtype`` 定义的类型一致。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. 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.]]
+

doc/fluid/api_cn/tensor_cn/zeros_like_cn.rst

-zeros
+.. _cn_api_tensor_zeros_like:
+
+zeros_like
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.zeros_like(input, dtype=None, device=None, name=None)
+
+
+该OP创建一个和input具有相同的形状和数据类型的全零Tensor。
+
+参数：
+    - **input** (Variable) – 指定输入为一个多维的Tensor，数据类型可以是bool，float32，float64，int32，int64。
+    - **dtype** （np.dtype|core.VarDesc.VarType|str， 可选）- 输出变量的数据类型。若参数为空，则输出变量的数据类型和输入变量相同，默认值为None。
+    - **device** (str，可选) – 选择在哪个设备运行该操作，可选值包括None，'cpu'和'gpu'。如果 ``device`` 为None，则将选择运行Paddle程序的设备，默认为None。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+    
+返回：返回一个存储结果的Tensor。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+    x = fluid.data(name='x', dtype='float32', shape=[3])
+    data1 = paddle.ones_like(input=x, device="gpu") # data1=[1.0, 1.0. 1.0]
+