modify format

docs/api/api_python/dataset/mindspore.dataset.config.get_prefetch_size.rst

@@ -1,4 +1,4 @@
-mindspore.dataset.config.set_prefetch_size
+mindspore.dataset.config.get_prefetch_size
 ===========================================
 
 .. py:function:: mindspore.dataset.config.get_prefetch_size()

docs/api/api_python/mindspore.boost.rst

@@ -226,7 +226,7 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
         - **sens** (numbers.Number) - 作为反向传播输入要填充的缩放数，默认值为1.0。
 
     输入：
-        - **(*inputs)** (Tuple(Tensor)) - 网络的所有输入组成的元组。
+        - **\*inputs** (Tuple(Tensor)) - 网络的所有输入组成的元组。
 
     输出：
         Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。
@@ -299,7 +299,7 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
         - **scale_sense** (Union[Tensor, Cell]) - 如果此值为Cell类型，`BoostTrainOneStepWithLossScaleCell` 会调用它来更新损失缩放系数。如果此值为Tensor类型，可调用 `set_sense_scale` 来更新损失缩放系数，shape为 :math:`()` 或 :math:`(1,)` 。
 
     输入：
-        - **(*inputs)** (Tuple(Tensor)) - 网络的所有输入组成的元组。
+        - **\*inputs** (Tuple(Tensor)) - 网络的所有输入组成的元组。
 
     输出：
         Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。
@@ -460,7 +460,7 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
         - **old_grad** (Tuple(Tensor)) - 网络权重提取组成的元组。
         - **weight** (Tuple(Tensor)) - 网络权重组成的元组。
         - **weight_clone** (Tuple(Tensor)) - 网络权重的副本。
-        - **(\*inputs)** (Tuple(Tensor)) - 网络的所有输入组成的元组。
+        - **\*inputs** (Tuple(Tensor)) - 网络的所有输入组成的元组。
 
     输出：
         - **loss** (Tensor) - 网络loss，标量Tensor。

docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool1d.rst

@@ -1,7 +1,7 @@
 mindspore.nn.AdaptiveMaxPool1d
 ==============================
 
-.. py:class:: mindspore.nn.AdaptiveMaxPool1d(output_size)
+.. py:class:: mindspore.nn.AdaptiveMaxPool1d(output_size, return_indices=False)
 
     在一个输入Tensor上应用1D自适应最大池化运算，可被视为组成一个1D输入平面。
 

docs/api/api_python/nn/mindspore.nn.ForwardValueAndGrad.rst

@@ -16,8 +16,8 @@ mindspore.nn.ForwardValueAndGrad
         - **sens_param** (bool) - 是否将sens作为输入。如果 `sens_param` 为False，则sens默认为'ones_like(outputs)'。默认值：False。如果 `sens_param` 为True，则需要指定sens的值。
 
     输入：
-        - **(\*inputs)** (Tuple(Tensor...)) - shape为 :math:`(N, \ldots)` 的输入tuple。
+        - **\*inputs** (Tuple(Tensor...)) - shape为 :math:`(N, \ldots)` 的输入tuple。
-        - **(sens)** - 反向传播梯度的缩放值。如果网络有单个输出，则sens是tensor。如果网络有多个输出，则sens是tuple(tensor)。
+        - **sens** - 反向传播梯度的缩放值。如果网络有单个输出，则sens是tensor。如果网络有多个输出，则sens是tuple(tensor)。
 
     输出：
         - **forward value** - 网络运行的正向结果。

docs/api/api_python/nn/mindspore.nn.MultiheadAttention.rst

@@ -15,7 +15,7 @@ mindspore.nn.MultiheadAttention
     参数：
         - **embed_dim** (int) - 模型的总维数。
         - **num_heads** (int) - 并行注意力头的数量。``num_heads`` 需要能够被 ``embed_dim`` 整除（每个头的维数为 ``embed_dim // num_heads``）。
-        - **dropout** (float) - 应用到输入 ``attn_output_weights``上的随机丢弃比例. 默认： ``0.0`` （不丢弃）。
+        - **dropout** (float) - 应用到输入 ``attn_output_weights`` 上的随机丢弃比例. 默认： ``0.0`` （不丢弃）。
         - **has_bias** (bool) - 是否给输入、输出投射层添加偏置。默认： ``True``。
         - **add_bias_kv** (bool) - 是否给key、value序列的0维添加偏置。默认： ``False``。
         - **add_zero_attn** (bool) - 是否给key、value序列的1维添加0。默认： ``False``。
@@ -33,10 +33,10 @@ mindspore.nn.MultiheadAttention
           当 ``batch_first=True`` 时，Shape为 :math:`(N, S, E_v)`。其中， :math:`S` 为源序列的长度， :math:`N` 为batch size，:math:`E_v` 为Key矩阵的维数 ``vdim``。详情请见："Attention Is All You Need"。
         - **key_padding_mask** (Tensor) - 如果指定此值，则表示Shape为 :math:`(N, S)`的掩码将被用于 ``key``。当输入非Batch数据时，Shape为： :math:`(S)` 。
           如果输入Tensor为Bool类型，则 ``key`` 中对应为 ``True`` 的位置将在Attention计算时被忽略。如果输入Tensor为Float类型，则将直接与 ``key`` 相加。默认：``None``。
-        - **need_weights** (bool) - 是否需要返回 ``attn_output_weights``，如果为 ``True``，则输出包含``attn_output_weights``。默认：``True``。
+        - **need_weights** (bool) - 是否需要返回 ``attn_output_weights``，如果为 ``True``，则输出包含 ``attn_output_weights``。默认：``True``。
         - **attn_mask** (Tensor) - 如果指定此值，则表示Shape为 :math:`(L, S)` 或 :math:`(N\cdot\text{num\_heads}, L, S)` 的掩码将被用于Attention计算。其中 :math:`N` 为batch size，
           :math:`L` 为目标序列长度，:math:`S` 为源序列长度。如果输入为2维矩阵，则将自动沿batch维广播至3维矩阵。若为3维矩阵，则允许沿batch维使用不同的掩码。如果输入Tensor为Bool类型，则值为 ``True`` 对应位置允许被注意力计算。如果输入Tensor为Float类型，则将直接与注意力权重相加。默认：``None``。
-        - **average_attn_weights** (bool) - 如果为 ``True``， 则返回值 ``attn_weights`` 为注意力头的平均值。如果为 ``False``，则``attn_weights``分别返回每个注意力头的值。
+        - **average_attn_weights** (bool) - 如果为 ``True``， 则返回值 ``attn_weights`` 为注意力头的平均值。如果为 ``False``，则 ``attn_weights`` 分别返回每个注意力头的值。
           本参数仅在 ``need_weights=True`` 时生效。默认： ``True`` 。
 
     输出：

docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.rst

@@ -14,7 +14,7 @@ mindspore.nn.TrainOneStepCell
         - **sens** (numbers.Number) - 反向传播的输入，缩放系数。默认值为1.0。
 
     输入：
-        - **(\*inputs)** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
+        - **\*inputs** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
 
     输出：
         Tensor，损失函数值，其shape通常为 :math:`()` 。

docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.rst

@@ -14,7 +14,7 @@ mindspore.nn.TrainOneStepWithLossScaleCell
         - **scale_sense** (Union[Tensor, Cell]) - 如果此值为Cell类型，`TrainOneStepWithLossScaleCell` 会调用它来更新损失缩放系数。如果此值为Tensor类型，可调用 `set_sense_scale` 来更新损失缩放系数，shape为 :math:`()` 或 :math:`(1,)` 。
 
     输入：
-        - **(*inputs)** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
+        - **\*inputs** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
 
     输出：
         Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。

docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool2d.rst

@@ -1,7 +1,7 @@
 mindspore.ops.adaptive_avg_pool2d
 =================================
 
-.. py:function:: mindspore.ops.adaptive_avg_pool2d(input_x, output_size)
+.. py:function:: mindspore.ops.adaptive_avg_pool2d(input, output_size)
 
     对输入Tensor，提供二维的自适应平均池化操作。也就是说，对于输入任何尺寸，指定输出的尺寸都为H * W。但是输入和输出特征的数目不会变化。
 
@@ -20,13 +20,13 @@ mindspore.ops.adaptive_avg_pool2d
         \end{align}
 
     参数：
-        - **input_x** (Tensor) - adaptive_avg_pool2d的输入，为三维或四维的Tensor，数据类型为float16、float32或者float64。
+        - **input** (Tensor) - adaptive_avg_pool2d的输入，为三维或四维的Tensor，数据类型为float16、float32或者float64。
         - **output_size** (Union[int, tuple]) - 输出特征图的尺寸为H * W。可以是int类型的H和W组成的tuple，或代表相同H和W的一个int值，或None，如果是None，则意味着输出大小与输入相同。
 
     返回：
-        Tensor，数据类型与 `input_x` 相同。
+        Tensor，数据类型与 `input` 相同。
 
-        输出的shape为 `input_x_shape[:len(input_x_shape) - len(out_shape)] + out_shape` 。
+        输出的shape为 `input_shape[:len(input_shape) - len(out_shape)] + out_shape` 。
 
         .. math::
             out\_shape = \begin{cases}
@@ -39,6 +39,6 @@ mindspore.ops.adaptive_avg_pool2d
 
     异常：
         - **ValueError** - 如果 `output_size` 是tuple，并且 `output_size` 的长度不是2。
-        - **ValueError** - 如果 `input_x` 的维度小于或等于 `output_size` 的维度。
+        - **ValueError** - 如果 `input` 的维度小于或等于 `output_size` 的维度。
-        - **TypeError** - 如果 `input_x` 不是Tensor。
+        - **TypeError** - 如果 `input` 不是Tensor。
-        - **TypeError** - 如果 `input_x` 的数据类型不是float16、float32或者float64。
+        - **TypeError** - 如果 `input` 的数据类型不是float16、float32或者float64。

docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool1d.rst

@@ -1,7 +1,7 @@
 mindspore.ops.adaptive_max_pool1d
 =================================
 
-.. py:function:: mindspore.ops.adaptive_max_pool1d(input_x, output_size, return_indices=False)
+.. py:function:: mindspore.ops.adaptive_max_pool1d(input, output_size, return_indices=False)
 
     对可以看作是由一系列1D平面组成的输入Tensor，应用一维自适应最大池化操作。
 
@@ -12,17 +12,17 @@ mindspore.ops.adaptive_max_pool1d
         Ascend平台不支持 `return_indices` 参数。
 
     参数：
-        - **input_x** (Tensor) - 输入shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C_{in}, L_{in})` ，数据类型为float16、float32。
+        - **input** (Tensor) - 输入shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C_{in}, L_{in})` ，数据类型为float16、float32。
         - **output_size** (int) - 大小为 :math:`L_{out}` 。
         - **return_indices** (bool) - 如果为True，输出最大值的索引，默认值为False。
 
     返回：
-        Tensor，数据类型与 `input_x` 相同。
+        Tensor，数据类型与 `input` 相同。
         输出的shape为 :math:`(N_{in}, C_{in}, L_{out})` 或 :math:`(C_{in}, L_{out})` 。
 
     异常：
-        - **TypeError** - 如果 `input_x` 不是Tensor。
+        - **TypeError** - 如果 `input` 不是Tensor。
         - **TypeError** - 如果 `output_size` 不是int类型。
         - **TypeError** - 如果 `return_indices` 不是bool类型。
         - **ValueError** - 如果 `output_size` 小于1。
-        - **ValueError** - 如果 `input_x` 的维度不等于2或3。
+        - **ValueError** - 如果 `input` 的维度不等于2或3。

docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool2d.rst

@@ -1,7 +1,7 @@
 mindspore.ops.adaptive_max_pool2d
 =================================
 
-.. py:function:: mindspore.ops.adaptive_max_pool2d(input_x, output_size, return_indices=False)
+.. py:function:: mindspore.ops.adaptive_max_pool2d(input, output_size, return_indices=False)
 
     对输入Tensor，提供二维自适应最大池化操作。即对于输入任何尺寸，指定输出的尺寸都为H * W。但是输入和输出特征的数目不会变化。
 
@@ -18,22 +18,22 @@ mindspore.ops.adaptive_max_pool2d
         \end{align}
 
     .. note::
-        Ascend平台input_x参数仅支持float16类型。
+        Ascend平台input参数仅支持float16类型。
 
     参数：
-        - **input_x** (Tensor) - adaptive_max_pool2d的输入，为三维或四维的Tensor，数据类型为float16、float32或者float64。
+        - **input** (Tensor) - adaptive_max_pool2d的输入，为三维或四维的Tensor，数据类型为float16、float32或者float64。
         - **output_size** (Union[int, tuple]) - 输出特征图的尺寸为H * W。可以是int类型的H和W组成的tuple，或代表相同H和W的一个int值，或None，如果是None，则意味着输出大小与输入相同。
         - **return_indices** (bool) - 如果为True，输出最大值的索引，默认值为False。
 
     返回：
-        Tensor，数据类型与 `input_x` 相同。
+        Tensor，数据类型与 `input` 相同。
 
-        输出的shape为 `input_x_shape[:len(input_x_shape) - len(out_shape)] + out_shape` 。
+        输出的shape为 `input_shape[:len(input_shape) - len(out_shape)] + out_shape` 。
 
     异常：
-        - **TypeError** - `input_x` 不是Tensor。
+        - **TypeError** - `input` 不是Tensor。
-        - **TypeError** - `input_x` 中的数据不是float16, float32, float64.
+        - **TypeError** - `input` 中的数据不是float16, float32, float64.
         - **TypeError** - `output_size` 不是int或者tuple。
         - **TypeError** - `return_indices` 不是bool。
         - **ValueError** - `output_size` 是tuple，但大小不是2。
-        - **ValueError** - `input_x` 的维度不是CHW或者NCHW。
+        - **ValueError** - `input` 的维度不是CHW或者NCHW。

docs/api/api_python/ops/mindspore.ops.func_count_nonzero.rst

@@ -1,7 +1,7 @@
 mindspore.ops.count_nonzero
 ============================
 
-.. py:function:: mindspore.ops.count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32)
+.. py:function:: mindspore.ops.count_nonzero(x, dims=None)
 
     计算输入Tensor指定轴上的非零元素的数量。如果没有指定维度，则计算Tensor中所有非零元素的数量。
 

docs/api/api_python/ops/mindspore.ops.func_polygamma.rst

@@ -11,7 +11,7 @@ mindspore.ops.polygamma
     其中\psi(x)为digamma函数。
 
     参数：
-        - **a** (tuple) - 多伽马函数求导的阶数，支持的数据类型为int32和int64， `a` 的shape为 :math:`()` 。
+        - **a** (Tensor) - 多伽马函数求导的阶数，支持的数据类型为int32和int64， `a` 的shape为 :math:`()` 。
         - **x** (Tensor) - 用于计算多伽马函数的Tensor。
 
     返回：

docs/api/api_python/ops/mindspore.ops.func_triu_indices.rst

@@ -14,7 +14,7 @@ mindspore.ops.triu_indices
         - **row** (int) - 2-D 矩阵的行数。
         - **col** (int) - 2-D 矩阵的列数。
         - **offset** (int，可选) - 对角线偏移量。默认值：0。
-        - **dtype** (:class:`mindspore.dtype` ，可选) - 指定输出Tensor数据类型，支持的数据类型为 `mstype.int32` 和 `mstype.int64` ，默认值： `mstype.int64` 。
+        - **dtype** (:class:`mindspore.dtype`，可选) - 指定输出Tensor数据类型，支持的数据类型为 `mstype.int32` 和 `mstype.int64` ，默认值： `mstype.int64` 。
 
     返回：
         - **y** (Tensor) - 矩阵的下三角形部分的索引。数据类型由 `dtype` 指定，shape为 :math:`(2, tril\_size)` ，其中， `tril_size` 为上三角矩阵的元素总数。

mindspore/python/mindspore/boost/boost_cell_wrapper.py

@@ -115,7 +115,7 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         sens (numbers.Number): The scaling number to be filled as the input of backpropagation. Default value is 1.0.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tensor, a tensor means the loss value, the shape of which is usually :math:`()`.
@@ -392,7 +392,7 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
                                           is Tensor type, Tensor with shape :math:`()` or :math:`(1,)`.
 
     Inputs:
-        - **(*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tuple of 3 Tensor, the loss, overflow flag and current loss scaling value.

mindspore/python/mindspore/boost/dim_reduce.py

@@ -138,7 +138,7 @@ class DimReduce(Cell):
         - **old_grad** (Tuple(Tensor)) - Tuple of gradient tensors.
         - **weight** (Tuple(Tensor)) - Tuple of parameters.
         - **weight_clone** (Tuple(Tensor)) - clone of weight
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         - **loss** (Tensor) - Tensor with shape :math:`()`.

mindspore/python/mindspore/context.py

@@ -1022,24 +1022,24 @@ def set_context(**kwargs):
               value of training network is must_keep_origin_dtype, and the default value of inference network
               is force_fp16. The value range is as follows:
 
-                - force_fp16: When the operator supports both float16 and float32, select float16 directly.
+              - force_fp16: When the operator supports both float16 and float32, select float16 directly.
-                - allow_fp32_to_fp16: When the operator does not support the float32 data type, directly reduce
+              - allow_fp32_to_fp16: When the operator does not support the float32 data type, directly reduce
-                  the precision of float16.
+                the precision of float16.
-                - allow_mix_precision: Automatic mixing precision, facing the whole network operator, according
+              - allow_mix_precision: Automatic mixing precision, facing the whole network operator, according
-                  to the built-in optimization strategy, automatically reduces the precision of some operators
+                to the built-in optimization strategy, automatically reduces the precision of some operators
-                  to float16 or bfloat16.
+                to float16 or bfloat16.
-                - must_keep_origin_dtype: Keep the accuracy of the original drawing.
+              - must_keep_origin_dtype: Keep the accuracy of the original drawing.
-                - force_fp32: When the operator supports both float16 and float32, select float32 directly.
+              - force_fp32: When the operator supports both float16 and float32, select float32 directly.
-                - force_lowerprecision: When the operator supports both float16 or bfloat16 and float32, select
+              - force_lowerprecision: When the operator supports both float16 or bfloat16 and float32, select
-                  float16 or bfloat16 directly.
+                float16 or bfloat16 directly.
-                - allow_fp32_to_bf16: When the operator does not support the float32 data type, directly reduce
+              - allow_fp32_to_bf16: When the operator does not support the float32 data type, directly reduce
-                  the precision of bfloat16.
+                the precision of bfloat16.
-                - allow_fp32_to_lowprecision: When the operator does not support the float32 data type, directly
+              - allow_fp32_to_lowprecision: When the operator does not support the float32 data type, directly
-                  reduce the precision of float16 or bfloat16.
+                reduce the precision of float16 or bfloat16.
-                - allow_mix_precision_fp16: Automatic mixing precision, facing the whole network operator, automatically
+              - allow_mix_precision_fp16: Automatic mixing precision, facing the whole network operator, automatically
-                  reduces the precision of some operators to float16 according to the built-in optimization strategy.
+                reduces the precision of some operators to float16 according to the built-in optimization strategy.
-                - allow_mix_precision_bf16: Automatic mixing precision, facing the whole network operator, according to
+              - allow_mix_precision_bf16: Automatic mixing precision, facing the whole network operator, according to
-                  the built-in optimization strategy, automatically reduces the precision of some operators to bfloat16.
+                the built-in optimization strategy, automatically reduces the precision of some operators to bfloat16.
 
             - jit_compile (bool): Whether to select online compilation. Default: True.
 

mindspore/python/mindspore/nn/wrap/cell_wrapper.py

@@ -146,7 +146,7 @@ class WithGradCell(Cell):
             output value. Default: None.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         list, a list of Tensors with identical shapes as trainable weights.
@@ -217,8 +217,8 @@ class ForwardValueAndGrad(Cell):
             the input parameter.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor...)) - Tuple of inputs with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor...)) - Tuple of inputs with shape :math:`(N, \ldots)`.
-        - **(sens)** - A sensitivity (gradient with respect to output) as the input of backpropagation.
+        - **sens** - A sensitivity (gradient with respect to output) as the input of backpropagation.
           If network has single output, the sens is a tensor.
           If network has multiple outputs, the sens is the tuple(tensor).
 
@@ -312,7 +312,7 @@ class TrainOneStepCell(Cell):
         sens (numbers.Number): The scaling number to be filled as the input of backpropagation. Default value is 1.0.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tensor, a tensor means the loss value, the shape of which is usually :math:`()`.

mindspore/python/mindspore/nn/wrap/loss_scale.py

@@ -244,7 +244,7 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
             the shape should be :math:`()` or :math:`(1,)`.
 
     Inputs:
-        - **(*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tuple of 3 Tensor, the loss, overflow flag and current loss scale value.

mindspore/python/mindspore/ops/function/nn_func.py

@@ -76,7 +76,7 @@ def adaptive_avg_pool2d(input, output_size):
 
     Args:
         input (Tensor): The input of adaptive_avg_pool2d, which is a 3D or 4D tensor,
-          with float16, float32 or float64 data type.
+            with float16, float32 or float64 data type.
         output_size (Union[int, tuple]): The target output size is H x W.
             `ouput_size` can be a tuple consisted of int type H and W, or a single H for H x H, or None.
             If it is None, it means the output size is the same as the input size.