Fix docs(91-100) (#5504)

* 将paddle.linspace的返回值"mum"修改为"num"

* 将paddle.linspace的返回值"mum"修改为"num"，修改了paddle.linspace 支持了0-D Tensor，并将数据类型的排序与英文版文档一致

* Update linspace_cn.rst

* Update sequence_enumerate_cn.rst

* Update shard_index_cn.rst

* Update py_func_cn.rst

* Update auc_cn.rst

Co-authored-by: Ligoml <39876205+Ligoml@users.noreply.github.com>

docs/api/paddle/linspace_cn.rst

@@ -11,15 +11,15 @@ linspace
 参数
 ::::::::::::
 
-    - **start** (int|float|Tensor) – ``start`` 是区间开始的变量，可以是一个浮点标量，或是一个 shape 为[1]的 Tensor，该 Tensor 的数据类型可以是 float32，float64，int32 或者 int64。
-    - **stop** (int|float|Tensor) – ``stop`` 是区间结束的变量，可以是一个浮点标量，或是一个 shape 为[1]的 Tensor，该 Tensor 的数据类型可以是 float32，float64，int32 或者 int64。
-    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个整型标量，或是一个 shape 为[1]的 Tensor，该 Tensor 的数据类型需为 int32。
-    - **dtype** (np.dtype|str，可选) – 输出 Tensor 的数据类型，可以是 float32，float64， int32 或者 int64。如果 dtype 的数据类型为 None，输出 Tensor 数据类型为 float32。
+    - **start** (int|float|Tensor) – ``start`` 是区间开始的变量，可以是一个int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
+    - **stop** (int|float|Tensor) – ``stop`` 是区间结束的变量，可以是一个int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
+    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个int，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型需为 int32。
+    - **dtype** (np.dtype|str，可选) – 输出 Tensor 的数据类型，可以是 int32，int64，float32，float64。如果 dtype 的数据类型为 None，输出 Tensor 数据类型为 float32。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-表示等间隔划分结果的 1-D Tensor，该 Tensor 的 shape 大小为 :math:`[num]`，在 mum 为 1 的情况下，仅返回包含 start 元素值的 Tensor。
+表示等间隔划分结果的 1-D Tensor，该 Tensor 的 shape 大小为 :math:`[num]`，在 num 为 1 的情况下，仅返回包含 start 元素值的 Tensor。
 
 
 代码示例

docs/api/paddle/shard_index_cn.rst

@@ -24,7 +24,7 @@ shard_index
     - **index_num** (int) - 用户设置的大于 :attr:`input` 最大值的整型值。
     - **nshards** (int) - 分片数量。
     - **shard_id** (int) - 当前分片 ID。
-    - **ignore_value** (int) - 超出分片范围的默认值。
+    - **ignore_value** (int，可选) - 超出分片索引范围的整数值。默认值为 -1。
 
 返回
 ::::::::::::

docs/api/paddle/static/auc_cn.rst

@@ -27,15 +27,15 @@ auc
 
     - **input** (Tensor) - 数据类型为 float32、float64。浮点二维变量，值的范围为[0,1]。每一行降序排列。该输入为网络预测值，通常代表每个标签的概率。
     - **label** (Tensor) - 数据类型为 int32、int64。二维整型变量，为训练数据的标签，第一维大小代表 batch size，第二维大小为 1。
-    - **curve** (str) - 曲线类型，可以为 ``ROC`` 或 ``PR``，默认 ``ROC``。
-    - **num_thresholds** (int) - 将 roc 曲线离散化时使用的临界值数。默认 4095。
-    - **topk** (int) -  取 topk 的输出值用于计算。
-    - **slide_steps** (int) - 当计算 batch auc 时，不仅用当前步也用于先前步。slide_steps=1，表示用当前步；slide_steps = 3 表示用当前步和前两步；slide_steps = 0，则用所有步。
-    - **ins_tag_weight** (Tensor) - 在多 instag 场景下，该数值代表着数据的真伪性，如果为 0，说明数据是被填充的假数据，如果为 1，说明为真数据。默认为 None，此时该数值被赋值为 1。
+    - **curve** (str，可选) - 曲线类型，可以为 ``ROC`` 或 ``PR``，默认 ``ROC``。
+    - **num_thresholds** (int，可选) - 将 roc 曲线离散化时使用的临界值数。默认 4095。
+    - **topk** (int，可选) -  取 topk 的输出值用于计算。
+    - **slide_steps** (int，可选) - 当计算 batch auc 时，不仅用当前步也用于先前步。slide_steps=1，表示用当前步；slide_steps = 3 表示用当前步和前两步；slide_steps = 0，则用所有步。默认值为 1。
+    - **ins_tag_weight** (Tensor，可选) - 在多 instag 场景下，该数值代表着数据的真伪性，如果为 0，说明数据是被填充的假数据，如果为 1，说明为真数据。默认为 None，此时该数值被赋值为 1。
 
 返回
 ::::::::::::
-tuple，当前计算出的 AUC。数据类型是 tensor，支持 float32 和 float64。
+tuple，当前计算出的 AUC。数据类型是 Tensor，支持 float32 和 float64。
 
 返回的元组为 auc_out, batch_auc_out, [batch_stat_pos, batch_stat_neg, stat_pos, stat_neg]。
 

docs/api/paddle/static/nn/sequence_enumerate_cn.rst

@@ -29,9 +29,9 @@ sequence_enumerate
 参数
 :::::::::
 
-        - **input** （Variable）- 输入序列，形状为 ``[d_1, 1]`` ，lod level 为 1 的 LodTensor。数据类型支持 int32，int64，float32 或 float64。
-        - **win_size** （int）- 子序列窗口大小。
-        - **pad_value** （int，可选）- 填充值，默认为 0。
+        - **input** (Tensor) - 输入序列，形状为 ``[d_1, 1]`` ，lod level 为 1 的 LodTensor。数据类型支持 int32，int64，float32 或 float64。
+        - **win_size** (int) - 子序列窗口大小。
+        - **pad_value** (int，可选) - 填充值，默认为 0。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回

docs/api/paddle/static/py_func_cn.rst

@@ -26,7 +26,7 @@ PaddlePaddle 通过 py_func 在 Python 端注册 OP。py_func 的设计原理在
     - **x** (Tensor|tuple(Tensor)|list[Tensor]) -  前向函数 ``func`` 的输入，多个 Tensor 以 tuple(Tensor)或 list[Tensor]的形式传入。
     - **out** (T|tuple(T)|list[T]) -  前向函数 ``func`` 的输出，可以为 T|tuple(T)|list[T]，其中 T 既可以为 Tensor，也可以为 numpy 数组。由于 Paddle 无法自动推断 ``out`` 的形状和数据类型，必须应事先创建 ``out`` 。
     - **backward_func** (callable，可选) - 所注册的 Python OP 的反向函数。默认值为 None，意味着没有反向计算。若不为 None，则会在运行网络反向时调用 ``backward_func`` 计算 ``x`` 的梯度。
-    - **skip_vars_in_backward_input** (Tensor) -  ``backward_func`` 的输入中不需要的变量，可以是 Tensor|tuple(Tensor)|list[Tensor]。这些变量必须是 ``x`` 和 ``out`` 中的一个。默认值为 None，意味着没有变量需要从 ``x`` 和 ``out`` 中去除。若不为 None，则这些变量将不是 ``backward_func`` 的输入。该参数仅在 ``backward_func`` 不为 None 时有用。
+    - **skip_vars_in_backward_input** (Tensor，可选) -  ``backward_func`` 的输入中不需要的变量，可以是 Tensor|tuple(Tensor)|list[Tensor]。这些变量必须是 ``x`` 和 ``out`` 中的一个。默认值为 None，意味着没有变量需要从 ``x`` 和 ``out`` 中去除。若不为 None，则这些变量将不是 ``backward_func`` 的输入。该参数仅在 ``backward_func`` 不为 None 时有用。
 
 返回
 ::::::::::::
@@ -37,120 +37,10 @@ Tensor|tuple(Tensor)|list[Tensor]，前向函数的输出 ``out``
 代码示例 1
 ::::::::::::
 
-.. code-block:: python
-
-    import paddle
-    import numpy as np
-
-    paddle.enable_static()
-
-    # 自定义的前向函数，可直接输入 LoDTenosor
-    def tanh(x):
-        return np.tanh(x)
-
-    # 在反向函数中跳过前向输入 x，返回 x 的梯度。
-    # 必须使用 np.array 主动将 LodTensor 转换为 numpy，否则"+/-"等操作无法使用
-    def tanh_grad(y, dy):
-        return np.array(dy) * (1 - np.square(np.array(y)))
-
-    # 自定义的前向函数，可用于调试正在运行的网络（打印值）
-    def debug_func(x):
-        print(x)
-
-    def create_tmp_var(name, dtype, shape):
-        return paddle.static.default_main_program().current_block().create_var(
-            name=name, dtype=dtype, shape=shape)
-
-    def simple_net(img, label):
-        hidden = img
-        for idx in range(4):
-            hidden = paddle.static.nn.fc(hidden, size=200)
-            new_hidden = create_tmp_var(name='hidden_{}'.format(idx),
-                dtype=hidden.dtype, shape=hidden.shape)
-
-            # 用户自定义的前向反向计算
-            hidden = paddle.static.py_func(func=tanh, x=hidden,
-                out=new_hidden, backward_func=tanh_grad,
-                skip_vars_in_backward_input=hidden)
-
-            # 用户自定义的调试函数，打印出输入的 LodTensor
-            paddle.static.py_func(func=debug_func, x=hidden, out=None)
-
-        prediction = paddle.static.nn.fc(hidden, size=10, activation='softmax')
-        ce_loss = paddle.nn.CrossEntropyLoss()
-        return ce_loss(prediction, label)
-
-    x = paddle.static.data(name='x', shape=[None, 4], dtype='float32')
-    y = paddle.static.data(name='y', shape=[10], dtype='int64')
-    res = simple_net(x, y)
-
-    exe = paddle.static.Executor(paddle.CPUPlace())
-    exe.run(paddle.static.default_startup_program())
-    input1 = np.random.random(size=[10, 4]).astype('float32')
-    input2 = np.random.randint(1, 10, size=[10], dtype='int64')
-    out = exe.run(paddle.static.default_main_program(),
-                  feed={'x':input1, 'y':input2},
-                  fetch_list=[res.name])
-    print(out)
+COPY-FROM: paddle.static.py_func:code-example1
 
 
 代码示例 2
 ::::::::::::
 
-..  code-block:: python
-
-    # 该示例展示了如何将 LoDTensor 转化为 numpy 数组，并利用 numpy API 来自定义一个 OP
-    import paddle
-    import numpy as np
-
-    paddle.enable_static()
-
-    def element_wise_add(x, y):
-        # 必须先手动将 LodTensor 转换为 numpy 数组，否则无法支持 numpy 的 shape 操作
-        x = np.array(x)
-        y = np.array(y)
-
-        if x.shape != y.shape:
-            raise AssertionError("the shape of inputs must be the same!")
-
-        result = np.zeros(x.shape, dtype='int32')
-        for i in range(len(x)):
-            for j in range(len(x[0])):
-                result[i][j] = x[i][j] + y[i][j]
-
-        return result
-
-    def create_tmp_var(name, dtype, shape):
-        return paddle.static.default_main_program().current_block().create_var(
-                    name=name, dtype=dtype, shape=shape)
-
-    def py_func_demo():
-        start_program = paddle.static.default_startup_program()
-        main_program = paddle.static.default_main_program()
-
-        # 创建前向函数的输入变量
-        x = paddle.static.data(name='x', shape=[2,3], dtype='int32')
-        y = paddle.static.data(name='y', shape=[2,3], dtype='int32')
-
-        # 创建前向函数的输出变量，必须指明变量名称 name/数据类型 dtype/维度 shape
-        output = create_tmp_var('output','int32', [3,1])
-
-        # 输入多个 LodTensor 以 list[Variable]或 tuple(Variable)形式
-        paddle.static.py_func(func=element_wise_add, x=[x,y], out=output)
-
-        exe=paddle.static.Executor(paddle.CPUPlace())
-        exe.run(start_program)
-
-        # 给 program 喂入 numpy 数组
-        input1 = np.random.randint(1, 10, size=[2,3], dtype='int32')
-        input2 = np.random.randint(1, 10, size=[2,3], dtype='int32')
-        out = exe.run(main_program,
-                    feed={'x':input1, 'y':input2},
-                    fetch_list=[output.name])
-        print("{0} + {1} = {2}".format(input1, input2, out))
-
-    py_func_demo()
-
-    # 参考输出：
-    # [[5, 9, 9]   + [[7, 8, 4]  =  [array([[12, 17, 13]
-    #  [7, 5, 2]]     [1, 3, 3]]            [8, 8, 5]], dtype=int32)]
+COPY-FROM: paddle.static.py_func:code-example2