mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/nn/layer/padding.py

@@ -208,24 +208,11 @@ class _ConstantPadNd(Cell):
             raise TypeError(msg)
 
         self.value = value
-        self.padding = _swap_to_ms_padding_order(padding)
-        self._name = name
+        self.padding = padding
 
     def construct(self, x):
         """Construct the pad net."""
-        input_shape = x.shape
-        padding = _check(input_shape, self.padding, self._name)
-        new_padding, start, end = _get_new_padding(padding)
-        mask = ops.OnesLike()(x)
-        output = ops.Pad(new_padding)(x)
-        mask = ops.Pad(new_padding)(mask)
-        ones = ops.OnesLike()(output)
-        value = ops.fill(output.dtype, output.shape, self.value)
-        output = ops.Add()(ops.Mul()(mask, output), ops.Mul()(ops.Sub()(ones, mask), value))
-        slice_op = ops.Slice()
-        begin, size = _get_begin_size(output.shape, start, end)
-        output = slice_op(output, begin, size)
-        return output
+        return ops.pad(x, padding=self.padding, mode='constant', value=self.value)
 
 
 class ConstantPad1d(_ConstantPadNd):
@@ -238,8 +225,13 @@ class ConstantPad1d(_ConstantPadNd):
             If a 2-tuple, uses (padding_0, padding_1) to pad. If the input is `x`, the size of last
             dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`. The remaining dimensions
             of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -248,6 +240,8 @@ class ConstantPad1d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` with tuple type is not equal to 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -316,8 +310,13 @@ class ConstantPad2d(_ConstantPadNd):
             If the input is `x`, the size of last dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`.
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -326,6 +325,8 @@ class ConstantPad2d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` is more than 4 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -369,8 +370,13 @@ class ConstantPad3d(_ConstantPadNd):
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The size of 3rd to last dimension of output is :math:`padding\_4 + x.shape[-3] + padding\_5`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -379,6 +385,8 @@ class ConstantPad3d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` is more than 6 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -620,6 +628,7 @@ class ZeroPad2d(_ConstantPadNd):
             If the input is `x`, the size of last dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`.
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
 
     Returns:
         Tensor, the tensor after padding.
@@ -628,6 +637,8 @@ class ZeroPad2d(_ConstantPadNd):
         TypeError: If `padding` is not a tuple or int.
         ValueError: If the length of `padding` is more than 4 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -679,18 +690,12 @@ class _ReplicationPadNd(Cell):
         self.padding = padding
         self.padv3 = nn_ops.PadV3(mode="edge")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        raise NotImplementedError
-
     @staticmethod
     @constexpr
     def _need_expend_dim(x):
         raise NotImplementedError
 
     def construct(self, x):
-        self._check_input_dim(x.shape, self.name)
         need_expend_dims = self._need_expend_dim(x)
         if need_expend_dims:
             x = x.expand_dims(0)
@@ -751,12 +756,6 @@ class ReplicationPad1d(_ReplicationPadNd):
             padding = (padding, padding)
         super(ReplicationPad1d, self).__init__(padding, name="ReplicationPad1d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 2, 3, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 2 else 0
@@ -821,12 +820,6 @@ class ReplicationPad2d(_ReplicationPadNd):
             padding = (padding, padding, padding, padding)
         super(ReplicationPad2d, self).__init__(padding, name="ReplicationPad2d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 3, 4, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 3 else 0
@@ -892,12 +885,6 @@ class ReplicationPad3d(_ReplicationPadNd):
             padding = (padding, padding, padding, padding, padding, padding)
         super(ReplicationPad3d, self).__init__(padding, name="ReplicationPad3d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 4, 5, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 4 else 0

mindspore/nn/layer/pooling.py

@@ -105,7 +105,8 @@ class LPPool1d(Cell):
         kernel_size (int): The size of kernel window.
         stride (int): The distance of kernel moving, an int number that represents the width of movement is stride,
             if the value is None, the default value `kernel_size` is used. Default: ``None`` .
-        ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: ``False`` .
+        ceil_mode (bool): If ``True``, use ceil to calculate output shape.
+            If ``False``, use ceil to calculate output shape. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
@@ -119,7 +120,7 @@ class LPPool1d(Cell):
 
 
     Raises:
-        TypeError: If `x` is not an Tensor.
+        TypeError: If `x` is not a Tensor.
         TypeError: If `kernel_size` or `stride` is not an int.
         TypeError: If `ceil_mode` is not a bool.
         TypeError: If `norm_type` is neither float nor int.
@@ -168,7 +169,7 @@ class LPPool2d(Cell):
         f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
 
     Args:
-        norm_type(Union[int, float]) - Type of normalization, represents :math:`p` in the formula, can not be 0.
+        norm_type(Union[int, float]): Type of normalization, represents :math:`p` in the formula, can not be 0.
 
             - if p = 1, the result is the sum of the elements within the pooling kernel(proportional to average
               pooling).
@@ -179,7 +180,7 @@ class LPPool2d(Cell):
             or a tuple of two int numbers that represent height and width respectively.
         stride(Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the height and width of movement are both stride, or a tuple of two int numbers that
-            represent height and width of movement respectively, if the value is None,
+            represent height and width of movement respectively, if the value is ``None``,
             the default value `kernel_size` is used. Default: ``None`` .
         ceil_mode(bool): Whether to use ceil or floor to calculate output shape. Default: ``False`` .
 
@@ -197,7 +198,7 @@ class LPPool2d(Cell):
             W_{out} = \left\lfloor\frac{W_{in} - \text{kernel_size}[1]}{\text{stride}[1]} + 1\right\rfloor
 
     Raises:
-        TypeError: If `x` is not an Tensor.
+        TypeError: If `x` is not a Tensor.
         TypeError: If `kernel_size` or `stride` is neither int nor tuple.
         TypeError: If `ceil_mode` is not a bool.
         TypeError: If `norm_type` is neither float nor int.
@@ -324,7 +325,8 @@ class MaxPool3d(_PoolNd):
             three integers. Default: ``1`` .
         return_indices (bool): If ``True`` , output is a Tuple of 2 Tensors, representing the maxpool result and where
             the max values are generated. Otherwise, only the maxpool result is returned. Default: ``False`` .
-        ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: ``False`` .
+        ceil_mode (bool): If ``True``, use ceil to calculate output shape.
+            If ``False``, use ceil to calculate output shape. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})` or
@@ -620,7 +622,7 @@ class MaxPool1d(_PoolNd):
               at the begin and end is determined by the `padding` parameter.
               If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Padding value for the pooling. Default value is 0.
+        padding (Union(int, tuple[int], list[int])): Padding value for the pooling. Default value is ``0``.
             padding can only be an integer or a tuple/list containing a single integer, in which case padding times or
             padding[0] times are padded on both sides of the input.
         dilation (Union(int, tuple[int])): The spacing between the elements of the kernel in convolution,
@@ -1660,6 +1662,8 @@ class AdaptiveMaxPool3d(Cell):
     def __init__(self, output_size, return_indices=False):
         """Initialize AdaptiveMaxPool3d."""
         super(AdaptiveMaxPool3d, self).__init__()
+        if isinstance(output_size, int):
+            output_size = (output_size, output_size, output_size)
         self.output_size = Tensor(output_size, dtype=mstype.int32)
         self.return_indices = return_indices
         self.adaptive_max_pool3d = AdaptiveMaxPool3D()
@@ -1975,7 +1979,7 @@ class MaxUnpool2d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the height and width of movement are both stride, or a tuple of two int numbers that
             represent height and width of movement respectively.
-            If stride is None, then stride equal to kernel_size. Default: ``None`` .
+            If stride is ``None``, then stride equal to kernel_size. Default: ``None`` .
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: ``0`` . If `padding` is an integer,
             the paddings of height and width are the same, equal to padding. If `padding` is a tuple of two
             integers, the padding of height and width equal to padding[0] and padding[1] correspondingly.
@@ -2068,7 +2072,7 @@ class MaxUnpool3d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the depth, height and width of movement are both stride, or a tuple of three int numbers that
             represent depth, height and width of movement respectively.
-            If stride is None, then stride equal to kernel_size. Default: ``None`` .
+            If stride is ``None``, then stride equal to kernel_size. Default: ``None`` .
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: ``0`` . If `padding` is an integer,
             the paddings of depth, height and width are the same, equal to padding. If `padding` is a tuple of three
             integers, the padding of depth, height and width equal to padding[0], padding[1] and padding[2]

mindspore/nn/layer/rnn_cells.py

@@ -25,7 +25,7 @@ from mindspore import log as logger
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, Uniform
-from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore.ops.primitive import constexpr
 from mindspore.nn.cell import Cell
 from mindspore import _checkparam as validator
 
@@ -61,13 +61,6 @@ def _check_tuple_length(param_name, input_data, length, cls_name):
                         f"but got '{len(input_data)}'")
 
 
-@_primexpr
-def _check_batch_size_equal(batch_size_x, batch_size_hx, cls_name):
-    if batch_size_x != batch_size_hx:
-        raise ValueError(f"For '{cls_name}' batch size of x and hx must be equal, but got {batch_size_x} of x "
-                         f"and {batch_size_hx} of hx.")
-
-
 def _check_lstmcell_init(func):
     """Internal function, used to check init args."""
     @wraps(func)
@@ -185,7 +178,7 @@ class RNNCell(RNNCellBase):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias :math:`b_ih` and :math:`b_hh`. Default: ``True`` .
         nonlinearity (str): The non-linearity to use. Can be either ``"tanh"`` or ``"relu"`` .
             Default: ``"tanh"`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
@@ -232,7 +225,6 @@ class RNNCell(RNNCellBase):
         _check_is_tensor('hx', hx, self.cls_name)
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx.dtype, "hx", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx.shape[0], self.cls_name)
 
         if self.nonlinearity == "tanh":
             ret = _rnn_tanh_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)
@@ -318,8 +310,6 @@ class LSTMCell(RNNCellBase):
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx[0].dtype, "hx[0]", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx[1].dtype, "hx[1]", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx[0].shape[0], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx[1].shape[0], self.cls_name)
         return _lstm_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)
 
     def _check_construct_args(self, *inputs, **kwargs):
@@ -346,7 +336,8 @@ class GRUCell(RNNCellBase):
         \end{array}
 
     Here :math:`\sigma` is the sigmoid function, and :math:`*` is the Hadamard product. :math:`W, b`
-    are learnable weights between the output and the input in the formula. For instance,
+    are learnable weights between the output and the input in the formula. :math:`h` is hidden state.
+    :math:`r` is reset gate. :math:`z` is update gate. :math:`n` is n-th layer. For instance,
     :math:`W_{ir}, b_{ir}` are the weight and bias used to transform from input :math:`x` to :math:`r`.
     Details can be found in paper
     `Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
@@ -355,7 +346,7 @@ class GRUCell(RNNCellBase):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        has_bias (bool): Whether the cell has bias `b_in` and `b_hn`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias :math:`b_{in}` and :math:`b_{hn}`. Default: ``True`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
@@ -394,5 +385,4 @@ class GRUCell(RNNCellBase):
         _check_is_tensor('hx', hx, self.cls_name)
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx.dtype, "hx", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx.shape[0], self.cls_name)
         return _gru_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)

mindspore/nn/layer/rnns.py

@@ -588,13 +588,14 @@ class RNN(_RNNBase):
     Here :math:`h_t` is the hidden state at time `t`, :math:`x_t` is
     the input at time `t`, and :math:`h_{(t-1)}` is the hidden state of the
     previous layer at time :math:`t-1` or the initial hidden state at time `0`.
-    If :attr:`nonlinearity` is ``'relu'``, then :math:`\text{ReLU}` is used instead of :math:`\tanh`.
+    :math:`W_{ih}` is the learnable input-hidden weights, and :math:`b_{ih}` is the learnable input-hidden bias.
+    :math:`W_{hh}` is the learnable hidden-hidden weights, and :math:`b_{hh}` is the learnable hidden-hidden bias.
 
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
         num_layers (int): Number of layers of stacked RNN. Default: ``1`` .
-        nonlinearity (str): The non-linearity to use. Can be either ``'tanh'`` or ``'relu'``. Default: ``'tanh'``
+        nonlinearity (str): The non-linearity to use. Can be either ``'tanh'`` or ``'relu'``. Default: ``'tanh'``.
         has_bias (bool): Whether the cell has bias :math:`b_{ih}` and :math:`b_{hh}`. Default: ``True`` .
         batch_first (bool): Specifies whether the first dimension of input `x` is batch_size. Default: ``False`` .
         dropout (float): If not 0.0, append `Dropout` layer on the outputs of each
@@ -696,7 +697,7 @@ class GRU(_RNNBase):
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
         num_layers (int): Number of layers of stacked GRU. Default: ``1`` .
-        has_bias (bool): Whether the cell has bias `b_in` and `b_hn`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias :math:`b_{in}` and :math:`b_{hn}`. Default: ``True`` .
         batch_first (bool): Specifies whether the first dimension of input `x` is batch_size. Default: ``False`` .
         dropout (float): If not 0.0, append `Dropout` layer on the outputs of each
             GRU layer except the last layer. Default ``0.0`` . The range of dropout is [0.0, 1.0).
@@ -706,7 +707,7 @@ class GRU(_RNNBase):
 
     Inputs:
         - **x** (Tensor) - Tensor of data type mindspore.float32 or mindspore.float16 and
-          shape (seq\_len, batch\_size, `input\_size`) or :math:`(batch\_size, seq\_len, input\_size)`.
+          shape :math:`(seq\_len, batch\_size, input\_size)` or :math:`(batch\_size, seq\_len, input\_size)`.
         - **hx** (Tensor) - Tensor of data type mindspore.float32 or mindspore.float16 and
           shape :math:`(num\_directions * num\_layers, batch\_size, hidden\_size)`.
         - **seq_length** (Tensor) - The length of each sequence in an input batch.
@@ -796,7 +797,7 @@ class LSTM(_RNNBase):
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
         num_layers (int): Number of layers of stacked LSTM . Default: ``1`` .
-        has_bias (bool): Whether the cell has bias :math:`b_{ih}` and :math:`b_{hh}`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias :math:`b_{ih}` and :math:`b_{fh}`. Default: ``True`` .
         batch_first (bool): Specifies whether the first dimension of input `x` is batch_size. Default: ``False`` .
         dropout (float, int): If not 0, append `Dropout` layer on the outputs of each
             LSTM layer except the last layer. Default ``0`` . The range of dropout is [0.0, 1.0).

mindspore/nn/layer/thor_layer.py

@@ -449,7 +449,7 @@ class Conv2dThor(_ConvThor):
             weight_shape = [1, self.in_channels, *self.kernel_size]
             self.weight_init = weight_init
             if isinstance(weight_init, Tensor):
-                self.weight_init = Tensor(weight_init.asnumpy().swapaxes(0, 1), weight_init.dtype)
+                self.weight_init = weight_init.swapaxes(0, 1)
             if isinstance(weight_init, Initializer):
                 self.weight_init.shape = weight_shape
             self.weight = Parameter(initializer(self.weight_init, weight_shape), name='weight')
@@ -596,7 +596,6 @@ class EmbeddingThor(Cell):
         if padding_idx is not None:
             self.padding_idx = Validator.check_int_range(padding_idx, 0, vocab_size, Validator.INC_BOTH,
                                                          "padding_idx", self.cls_name)
-            self.init_tensor = self.init_tensor.init_data().asnumpy()
             self.init_tensor[self.padding_idx] = 0
         self.embedding_table = Parameter(self.init_tensor, name='embedding_table')
         self.expand = P.ExpandDims()

mindspore/nn/layer/timedistributed.py

@@ -85,7 +85,7 @@ class TimeDistributed(Cell):
           where :math:`*` means any number of additional dimensions.
 
     Outputs:
-        Tensor of shape :math:`(N, T, *)`
+        Tensor of shape :math:`(N, T, *)`.
 
     Raises:
         TypeError: If layer is not a Cell or Primitive.

mindspore/nn/layer/transformer.py

@@ -66,35 +66,35 @@ class MultiheadAttention(Cell):
         dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
 
     Inputs:
-        - **query** (Tensor): The query embeddings. If `query` is unbatched, the shape is :math:`(L, E_q)`,
+        - **query** (Tensor) - The query embeddings. If `query` is unbatched, the shape is :math:`(L, E_q)`,
           otherwise the shape is :math:`(L, N, E_q)` when `batch_first=False` or :math:`(N, L, E_q)` when
           `batch_first=True` , where :math:`L`is the target sequence length, :math:`N` is the batch size,
           and :math:`E_q` is the query embedding dimension `embed_dim`. Supported types: float16, float32,
           float64. Queries are compared against key-value pairs to produce the output.
-        - **key** (Tensor): The key embeddings. If `key` is unbatched, the shape is :math:`(S, E_k)`, otherwise
+        - **key** (Tensor) - The key embeddings. If `key` is unbatched, the shape is :math:`(S, E_k)`, otherwise
           the shape is :math:`(S, N, E_k)` when `batch_first=False` or :math:`(N, S, E_k)` when
           `batch_first=True` , where :math:`S` is the source sequence length, :math:`N` is the batch size,
           and :math:`E_k` is the key embedding dimension `kdim`. Supported types: float16, float32, float64.
-        - **value** (Tensor): The value embeddings. If `value` is unbatched, the shape is :math:`(S, E_v)`,
+        - **value** (Tensor) - The value embeddings. If `value` is unbatched, the shape is :math:`(S, E_v)`,
           otherwise the shape is :math:`(S, N, E_v)` when `batch_first=False` or :math:`(N, S, E_v)` when
           `batch_first=True` , where :math:`S` is the source sequence length, :math:`N` is the batch size,
           and :math:`E_v` is the value embedding dimension `vdim`. Supported types: float16, float32, float64.
-        - **key_padding_mask** (Tensor, optional): If specified, a mask of shape :math:`(N, S)` indicating which
+        - **key_padding_mask** (Tensor, optional) - If specified, a mask of shape :math:`(N, S)` indicating which
           elements within `key` to ignore for the purpose of attention (i.e. treat as "padding").
           For unbatched `query`, shape should be :math:`(S)`. Binary and float masks are supported.
           For a binary mask, a ``True`` value indicates that the corresponding `key` value will be ignored for
           the purpose of attention. For a float mask, it will be directly added to the corresponding `key` value.
           Supported float types: float16, float32, float64. Default: ``None``.
-        - **need_weights** (bool): Whether returns `attn_output_weights` in addition to `attn_outputs`.
+        - **need_weights** (bool) - Whether returns `attn_output_weights` in addition to `attn_outputs`.
           Default: ``True``.
-        - **attn_mask** (Tensor, optional): If specified, a 2D or 3D mask preventing attention to certain positions.
+        - **attn_mask** (Tensor, optional) - If specified, a 2D or 3D mask preventing attention to certain positions.
           Must be of shape :math:`(L, S)` or :math:`(N\cdot\text{num_heads}, L, S)`, where :math:`N` is the
           batch size, :math:`L` is the target sequence length, and :math:`S` is the source sequence length.
           A 2D mask will be broadcasted across the batch while a 3D mask allows for a different mask for each entry
           in the batch. For a binary mask, a ``True`` value indicates that the corresponding position is not allowed
           to attend. For a float mask, the mask values will be added to the attention weight.
           Supported float types: float16, float32, float64. Default: ``None``.
-        - **average_attn_weights** (bool): If true, indicates that the returned `attn_weights` should be averaged
+        - **average_attn_weights** (bool) - If true, indicates that the returned `attn_weights` should be averaged
           across heads. Otherwise, `attn_weights` are provided separately per head. Note that this flag only
           has an effect when `need_weights=True`. Default: ``True`` (i.e. average weights across heads)
 
@@ -265,14 +265,14 @@ class TransformerEncoderLayer(Cell):
         dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
 
     Inputs:
-        - **src** (Tensor): the sequence to the encoder layer. For unbatched input, the shape is
+        - **src** (Tensor) - the sequence to the encoder layer. For unbatched input, the shape is
           :math:`(S, E)` ; otherwise if `batch_first=False` , the shape is :math:`(S, N, E)` and if
-          `batch_first=True` , the shape is :math:`(S, N, E)`, where :math:`(S)` is the source sequence
+          `batch_first=True` , the shape is :math:`(N, S, E)`, where :math:`(S)` is the source sequence
           length, :math:`(N)` is the batch number and :math:`(E)` is the feature number.
           Supported types: float16, float32, float64.
-        - **src_mask** (Tensor, optional): the mask for the src sequence. The shape is :math:`(S, S)`
+        - **src_mask** (Tensor, optional) - the mask for the src sequence. The shape is :math:`(S, S)`
           or :math:`(N*nhead, S, S)`. Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **src_key_padding_mask** (Tensor, optional): the mask for the src keys per batch. The shape is
+        - **src_key_padding_mask** (Tensor, optional) - the mask for the src keys per batch. The shape is
           :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
 
@@ -406,20 +406,20 @@ class TransformerDecoderLayer(Cell):
         dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
 
     Inputs:
-        - **tgt** (Tensor): The sequence to the decoder layer. For unbatched input, the shape is
+        - **tgt** (Tensor) - The sequence to the decoder layer. For unbatched input, the shape is
           :math:`(T, E)` ; otherwise if `batch_first=False` , the shape is :math:`(T, N, E)` and if
-          `batch_first=True` , the shape is :math:`(T, N, E)`, where :math:`(T)` is the target sequence
+          `batch_first=True` , the shape is :math:`(N, T, E)`, where :math:`(T)` is the target sequence
           length. Supported types: float16, float32, float64.
-        - **memory** (Tensor): The sequence from the last layer of the encoder. Supported types: float16,
+        - **memory** (Tensor) - The sequence from the last layer of the encoder. Supported types: float16,
           float32, float64.
-        - **tgt_mask** (Tensor, optional): The mask of the tgt sequence. The shape is :math:`(T, T)`
+        - **tgt_mask** (Tensor, optional) - The mask of the tgt sequence. The shape is :math:`(T, T)`
           or :math:`(N*nhead, T, T)`. Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **memory_mask** (Tensor, optional): The mask of the memory sequence. The shape is
+        - **memory_mask** (Tensor, optional) - The mask of the memory sequence. The shape is
           :math:`(T, S)` . Supported types: float16, float32, float64, bool. Default: ``None``.
         - **tgt_key_padding_mask** (Tensor, optional): The mask of the tgt keys per batch. The shape is
-          :math:`(T)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
+          :math:`(T)` for unbatched input, otherwise :math:`(N, T)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
-        - **memory_key_padding_mask** (Tensor, optional): The mask of the memory keys per batch. The shape
+        - **memory_key_padding_mask** (Tensor, optional) - The mask of the memory keys per batch. The shape
           is :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
 
@@ -540,8 +540,8 @@ class TransformerDecoderLayer(Cell):
 
 class TransformerEncoder(Cell):
     r"""
-    Transformer Encoder module with multi-layer stacked of `TransformerEncoderLayer`, including multihead
-    attention and feedforward layer. Users can build the
+    Transformer Encoder module with multi-layer stacked of :class:`mindspore.nn.TransformerEncoderLayer`,
+    including multihead attention and feedforward layer. Users can build the
     BERT(https://arxiv.org/abs/1810.04805) model with corresponding parameters.
 
     Args:
@@ -550,15 +550,15 @@ class TransformerEncoder(Cell):
         norm (Cell, optional): The layer normalization module. Default: ``None``.
 
     Inputs:
-        - **src** (Tensor): The sequence to the encoder. For unbatched input, the shape is
-          :math:`(S, E)` ; otherwise if `batch_first=False` in TransformerEncoderLayer, the shape is
-          :math:`(S, N, E)` and if `batch_first=True` , the shape is :math:`(S, N, E)`, where :math:`(S)` is the
-          source sequence length, :math:`(N)` is the batch number and :math:`(E)` is the feature number.
-          Supported types: float16, float32, float64.
-        - **src_mask** (Tensor, optional): The mask of the src sequence. The shape is :math:`(S, S)`
-          or :math:`(N*nhead, S, S)` , where `nhead` is the arguent in TransformerDecoderLayer.
+        - **src** (Tensor) - The sequence to the encoder. For unbatched input, the shape is
+          :math:`(S, E)` ; otherwise if `batch_first=False` in :class:`mindspore.nn.TransformerEncoderLayer`,
+          the shape is :math:`(S, N, E)` and if `batch_first=True` , the shape is :math:`(N, S, E)`,
+          where :math:`(S)` is the source sequence length, :math:`(N)` is the batch number and :math:`(E)` is
+          the feature number. Supported types: float16, float32, float64.
+        - **src_mask** (Tensor, optional) - The mask of the src sequence. The shape is :math:`(S, S)`
+          or :math:`(N*nhead, S, S)` , where `nhead` is the arguent in :class:`mindspore.nn.TransformerEncoderLayer`.
           Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **src_key_padding_mask** (Tensor, optional): the mask of the src keys per batch. The shape is
+        - **src_key_padding_mask** (Tensor, optional) - the mask of the src keys per batch. The shape is
           :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool.  Default: ``None``.
 
@@ -611,8 +611,8 @@ class TransformerEncoder(Cell):
 
 class TransformerDecoder(Cell):
     r"""
-    Transformer Decoder module with multi-layer stacked of `TransformerDecoderLayer`, including multihead self
-    attention, cross attention and feedforward layer.
+    Transformer Decoder module with multi-layer stacked of :class:`mindspore.nn.TransformerDecoderLayer`,
+    including multihead self attention, cross attention and feedforward layer.
 
     Args:
         decoder_layer (Cell): An instance of the :class:`mindspore.nn.TransformerDecoderLayer` class.
@@ -620,20 +620,22 @@ class TransformerDecoder(Cell):
         norm (Cell, optional): The layer normalization module. Default: ``None``.
 
     Inputs:
-        - **tgt** (Tensor): The sequence to the decoder. For unbatched input, the shape is
-          :math:`(T, E)` ; otherwise if `batch_first=False` in TransformerDecoderLayer, the shape is
-          :math:`(T, N, E)` and if `batch_first=True` , the shape is :math:`(T, N, E)`, where :math:`(T)` is the
-          target sequence length. Supported types: float16, float32, float64.
-        - **memory** (Tensor): The sequence from the last layer of the encoder. Supported types: float16,
+        - **tgt** (Tensor) - The sequence to the decoder. For unbatched input, the shape is
+          :math:`(T, E)` ; otherwise if `batch_first=False` in :class:`mindspore.nn.TransformerDecoderLayer`,
+          the shape is :math:`(T, N, E)` and if `batch_first=True` , the shape is :math:`(N, T, E)`,
+          where :math:`(T)` is the target sequence length, :math:`(N)` is the number of batches,
+          and :math:`(E)` is the number of features. Supported types: float16, float32, float64.
+        - **memory** (Tensor) - The sequence from the last layer of the encoder. Supported types: float16,
           float32, float64.
-        - **tgt_mask** (Tensor, optional): the mask of the tgt sequence. The shape is :math:`(T, T)`
-          or :math:`(N*nhead, T, T)` , where `nhead` is the arguent in TransformerDecoderLayer.
+        - **tgt_mask** (Tensor, optional) - the mask of the tgt sequence. The shape is :math:`(T, T)`
+          or :math:`(N*nhead, T, T)` , where `nhead` is the arguent in :class:`mindspore.nn.TransformerDecoderLayer`.
           Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **memory_mask** (Tensor, optional): the mask of the memory sequence. The shape is
+        - **memory_mask** (Tensor, optional) - the mask of the memory sequence. The shape is
           :math:`(T, S)` . Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **tgt_key_padding_mask** (Tensor, optional): the mask of the tgt keys per batch. Supported
+        - **tgt_key_padding_mask** (Tensor, optional) - the mask of the tgt keys per batch.
+          Shape is :math:`(T)`. Supported
           types: float16, float32, float64, bool. Default: ``None``.
-        - **memory_key_padding_mask** (Tensor, optional): the mask of the memory keys per batch. The shape
+        - **memory_key_padding_mask** (Tensor, optional) - the mask of the memory keys per batch. The shape
           is :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
 
@@ -710,28 +712,28 @@ class Transformer(Cell):
         dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
 
     Inputs:
-        - **src** (Tensor): The source sequence to the encoder. For unbatched input, the shape is
+        - **src** (Tensor) - The source sequence to the encoder. For unbatched input, the shape is
           :math:`(S, E)` ; otherwise if `batch_first=False` , the shape is :math:`(S, N, E)` and if
-          `batch_first=True` , the shape is :math:`(S, N, E)`, where :math:`(S)` is the source sequence
+          `batch_first=True` , the shape is :math:`(N, S, E)`, where :math:`(S)` is the source sequence
           length, :math:`(N)` is the batch number and :math:`(E)` is the feature number. Supported
           types: float16, float32, float64.
-        - **tgt** (Tensor): The target sequence to the decoder. For unbatched input, the shape is
+        - **tgt** (Tensor) - The target sequence to the decoder. For unbatched input, the shape is
           :math:`(T, E)` ; otherwise if `batch_first=False` , the shape is :math:`(T, N, E)` and if
-          `batch_first=True` , the shape is :math:`(T, N, E)`, where :math:`(T)` is the target sequence
+          `batch_first=True` , the shape is :math:`(N, T, E)`, where :math:`(T)` is the target sequence
           length. Supported types: float16, float32, float64.
-        - **src_mask** (Tensor, optional): The mask of the src sequence. The shape is :math:`(S, S)`
+        - **src_mask** (Tensor, optional) - The mask of the src sequence. The shape is :math:`(S, S)`
           or :math:`(N*nhead, S, S)`. Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **tgt_mask** (Tensor, optional): The mask of the tgt sequence. The shape is :math:`(T, T)`
+        - **tgt_mask** (Tensor, optional) - The mask of the tgt sequence. The shape is :math:`(T, T)`
           or :math:`(N*nhead, T, T)`. Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **memory_mask** (Tensor, optional): The additive mask of the encoder output. The shape is
+        - **memory_mask** (Tensor, optional) - The additive mask of the encoder output. The shape is
           :math:`(T, S)` . Supported types: float16, float32, float64, bool. Default: ``None``.
-        - **src_key_padding_mask** (Tensor, optional): The mask of src keys per batch. The shape is
+        - **src_key_padding_mask** (Tensor, optional) - The mask of src keys per batch. The shape is
           :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
-        - **tgt_key_padding_mask** (Tensor, optional): The mask of tgt keys per batch. The shape is
+        - **tgt_key_padding_mask** (Tensor, optional) - The mask of tgt keys per batch. The shape is
           :math:`(T)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16, float32,
           float64, bool. Default: ``None``.
-        - **memory_key_padding_mask** (Tensor, optional): The mask of memory keys per batch. The shape
+        - **memory_key_padding_mask** (Tensor, optional) - The mask of memory keys per batch. The shape
           is :math:`(S)` for unbatched input, otherwise :math:`(N, S)` . Supported types: float16,
           float32, float64, bool. Default: ``None``.