!49741 fix docs issues

Merge pull request !49741 from luojianing/code_docs_master

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

@@ -18,7 +18,7 @@ mindspore.nn.MultiheadAttention
         - **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``。
+        - **add_zero_attn** (bool) - 是否给key、value序列的一维添加0。默认值： ``False``。
         - **kdim** (int) - key的总特征数。默认值： ``None`` （即 `kdim=embed_dim`）。
         - **vdim** (int) - value的总特征数。默认值：``None`` （即 `vdim=embed_dim`）。
         - **batch_first** (bool) - 如果为 ``True``，则输入输出Tensor的shape为 (batch, seq, feature)，否则shape为(seq, batch, feature)。 默认值： ``False`` 。

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

@@ -6,7 +6,7 @@ mindspore.nn.TransformerDecoder
     Transformer的解码器。多层 `TransformerDecoderLayer` 的堆叠，包括Self Attention层、MultiheadAttention层和FeedForward层。
 
     参数：
-        - **decoder_layer** (Cell) - TransformerDecoderLayer()的实例。
+        - **decoder_layer** (Cell) - :class:`mindspore.nn.TransformerDecoderLayer` 的实例。
         - **num_layers** (int) - 解码器层数。
         - **norm** (Cell, 可选) - 自定义LayerNorm层。
 

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

@@ -14,7 +14,7 @@ mindspore.ops.Multinomial
         - **dtype** (dtype) - 输出数据类型，必须是int32或者int64，默认类型：int32。
 
     输入：
-        - **x** (Tensor) - 包含累加概率和的输入Tensor，必须是1维或2维。CPU和GPU后端支持1维或者2维，Ascend后端仅支持2维。
+        - **x** (Tensor) - 包含累加概率和的输入Tensor，必须是一维或二维。CPU和GPU后端支持一维或者二维，Ascend后端仅支持二维。
         - **num_samples** (int) - 要抽取的样本数。
 
     输出：

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

@@ -13,7 +13,7 @@ mindspore.ops.dropout2d
     参数：
         - **input** (Tensor) - 一个形状为 :math:`(N, C, H, W)` 的 `4D` Tensor，其中N是批处理大小，`C` 是通道数，`H` 是特征高度，`W` 是特征宽度。其数据类型应为int8、int16、int32、int64、float16、float32或float64。
         - **p** (float) - 通道的丢弃概率，介于 0 和 1 之间，例如 `p` = 0.8，意味着80%的清零概率。默认值：0.5。
-        - **training** (bool) - 如果training为True, 则执行对`input`的某些通道概率清零的操作，否则，不执行。默认值：True。
+        - **training** (bool) - 如果training为True, 则执行对 `input` 的某些通道概率清零的操作，否则，不执行。默认值：True。
 
     返回：
         - Tensor，输出，具有与输入 `input` 相同的形状和数据类型。

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

@@ -1,7 +1,7 @@
 mindspore.ops.dropout3d
 =======================
 
-.. py:function:: mindspore.ops.dropout3d(input, p=0.5， training=True)
+.. py:function:: mindspore.ops.dropout3d(input, p=0.5, training=True)
 
     在训练期间，以服从伯努利分布的概率 `p` 随机将输入Tensor的某些通道归零（对于形状为 `NCDHW` 的 `5D` Tensor，其通道特征图指的是后三维 `DHW` 形状的三维特征图）。
     例如，在批处理输入中 :math:`i\_th` 批， :math:`j\_th` 通道的 `input[i, j]` `3D` Tensor 是一个待处理数据。
@@ -12,7 +12,7 @@ mindspore.ops.dropout3d
     参数：
         - **input** (Tensor) - 一个形状为 :math:`(N, C, D, H, W)` 的 `5D` Tensor，其中N是批处理大小，`C` 是通道数，`D` 是特征深度， `H` 是特征高度，`W` 是特征宽度。其数据类型应为int8、int16、int32、int64、float16、float32或float64。
         - **p** (float) - 通道的丢弃概率，介于 0 和 1 之间，例如 `p` = 0.8，意味着80%的清零概率。默认值：0.5。
-        - **training** (bool) - 如果training为True, 则执行对`input`的某些通道概率清零的操作，否则，不执行。默认值：True。
+        - **training** (bool) - 如果training为True, 则执行对 `input` 的某些通道概率清零的操作，否则，不执行。默认值：True。
 
     返回：
         - Tensor，输出，具有与输入 `input` 相同的形状和数据类型。

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

@@ -16,4 +16,4 @@ mindspore.ops.mv
 
     异常：
         - **TypeError** - `mat` 或 `vec` 不是Tensor。
-        - **ValueError** - `mat` 不是2维Tensor或 `vec` 不是1维Tensor。
+        - **ValueError** - `mat` 不是二维Tensor或 `vec` 不是一维Tensor。

mindspore/python/mindspore/nn/layer/transformer.py

@@ -511,7 +511,7 @@ class TransformerDecoder(Cell):
     attention, cross attention and feedforward layer.
 
     Args:
-        decoder_layer (Cell): An instance of the TransformerDecoderLayer() class.
+        decoder_layer (Cell): An instance of the :class:`mindspore.nn.TransformerDecoderLayer` class.
         num_layers (int): The number of decoder-layers in the decoder.
         norm (Cell, optional): The layer normalization module.
 

mindspore/python/mindspore/ops/function/array_func.py

@@ -5276,17 +5276,18 @@ def tensor_split(x, indices_or_sections, axis=0):
         x (Tensor): A Tensor to be divided.
         indices_or_sections (Union[int, tuple(int), list(int)]):
 
-          - If `indices_or_sections` is an integer n, input tensor will be split into n sections.
+            - If `indices_or_sections` is an integer n, input tensor will be split into n sections.
 
-            - If :math:`x.size(axis)` can be divisible by n, sub-sections will have equal size
-              :math:`x.size(axis) / n` .
-            - If :math:`x.size(axis)` is not divisible by n, the first :math:`x.size(axis) % n` sections
-              will have size :math:`x.size(axis) // n + 1` , and the rest will have size :math:`x.size(axis) // n` .
+              - If :math:`x.size(axis)` can be divisible by n, sub-sections will have equal size
+                :math:`x.size(axis) / n` .
+              - If :math:`x.size(axis)` is not divisible by n, the first :math:`x.size(axis) % n` sections
+                will have size :math:`x.size(axis) // n + 1` , and the rest will have size :math:`x.size(axis) // n` .
+
+            - If `indices_or_sections` is of type tuple(int) or list(int), the input tensor will be split at the
+              indices in the list or tuple. For example, given parameters :math:`indices\_or\_sections=[1, 4]`
+              and :math:`axis=0` , the input tensor will be split into sections :math:`x[:1]` , :math:`x[1:4]` ,
+              and :math:`x[4:]` .
 
-          - If `indices_or_sections` is of type tuple(int) or list(int), the input tensor will be split at the
-            indices in the list or tuple. For example, given parameters :math:`indices\_or\_sections=[1, 4]`
-            and :math:`axis=0` , the input tensor will be split into sections :math:`x[:1]` , :math:`x[1:4]` ,
-            and :math:`x[4:]` .
         axis (int): The axis along which to split. Default: 0.
 
     Returns:

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

@@ -4467,7 +4467,7 @@ def hardsigmoid(input_x):
         input_x (Tensor): Tensor of shape :math:`(*)`, where :math:`*` means any number of
           dimensions, with float16, float32 or float64 data type.
 
-    Outputs:
+    Returns:
         A Tensor whose dtype and shape are the same as `input_x`.
 
     Raises:
@@ -4479,7 +4479,7 @@ def hardsigmoid(input_x):
 
     Examples:
         >>> x = Tensor(np.array([ -3.5,  0,  4.3]), mindspore.float32)
-        >>> output = F.hardsigmoid(x)
+        >>> output = ops.hardsigmoid(x)
         >>> print(output)
         [0.  0.5 1. ]
     """