mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/nn/layer/normalization.py

@@ -286,37 +286,40 @@ class BatchNorm2d(_BatchNorm):
         Note that the formula for updating the :math:`moving\_mean` and :math:`moving\_var` is
 
         .. math::
-            \text{moving_mean}=\text{moving_mean*momentum}+μ_β\text{*(1−momentum)}\\
-            \text{moving_var}=\text{moving_var*momentum}+σ^2_β\text{*(1−momentum)}
+            \text{moving_mean}=\text{moving_mean*momentum}+μ_β\text{*(1-momentum)}\\
+            \text{moving_var}=\text{moving_var*momentum}+σ^2_β\text{*(1-momentum)}
 
         where :math:`moving\_mean` is the updated mean, :math:`moving\_var` is the updated variance,
-        :math:`μ_β, σ^2_β` are the observed value (mean and variance) of each batch of data.
+        :math:`μ_β, σ^2_β` are the observed value (mean and variance respectively) of each batch of data.
 
     Args:
         num_features (int): The number of channels of the input tensor. Expected input size is :math:`(N, C, H, W)`,
             `C` represents the number of channels.
-        eps (float): :math:`\epsilon` added to the denominator for numerical stability. Default: ``1e-5`` .
-        momentum (float): A floating hyperparameter of the momentum for the
+        eps (float, optional): :math:`\epsilon` added to the denominator for numerical stability. Default: ``1e-5`` .
+        momentum (float, optional): A floating hyperparameter of the momentum for the
             running_mean and running_var computation. Default: ``0.9`` .
-        affine (bool): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` can be learned.
+        affine (bool, optional): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` can be learned.
             Default: ``True`` .
-        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
+        gamma_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the
+            :math:`\gamma` weight.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
-        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
+        beta_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the
+            :math:`\beta` weight.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
-        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
+        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving mean.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
-        moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
+        moving_var_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for
+            the moving variance.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
-        use_batch_statistics (bool): Default: ``None`` .
+        use_batch_statistics (bool, optional): Default: ``None`` .
 
             - If ``true`` , use the mean value and variance value of current batch data and track running mean
               and running variance.
@@ -325,9 +328,9 @@ class BatchNorm2d(_BatchNorm):
               training and evaluation mode. During training, the parameter is set to true, and during evaluation, the
               parameter is set to false.
 
-        data_format (str): The optional value for data format, is ``'NHWC'`` or ``'NCHW'`` .
+        data_format (str, optional): The optional value for data format, is ``'NHWC'`` or ``'NCHW'`` .
             Default: ``'NCHW'`` .
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C, H, W)`. Supported types: float16, float32.
@@ -340,7 +343,7 @@ class BatchNorm2d(_BatchNorm):
         TypeError: If `eps` is not a float.
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
-        ValueError: If `data_format` is neither 'NHWC' not 'NCHW'.
+        ValueError: If `data_format` is neither ``'NHWC'`` not ``'NCHW'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -508,32 +511,34 @@ class SyncBatchNorm(_BatchNorm):
 
     Args:
         num_features (int): `C` from an expected input of size :math:`(N, C, H, W)`.
-        eps (float): :math:`\epsilon`, a value added to the denominator for numerical stability. Default: ``1e-5`` .
-        momentum (float): A floating hyperparameter of the momentum for the
+        eps (float, optional): :math:`\epsilon`, a value added to the denominator for numerical stability.
+            Default: ``1e-5`` .
+        momentum (float, optional): A floating hyperparameter of the momentum for the
             running_mean and running_var computation. Default: ``0.9`` .
-        affine (bool): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` can be learned.
+        affine (bool, optional): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` are learnable
+            parameters. When set to ``False`` , :math:`\gamma` and :math:`\beta` are unlearnable parameters.
             Default: ``True`` .
-        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+        gamma_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\gamma`
+            weight. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
-        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
+        beta_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\beta` weight.
             The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
+        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving mean.
             The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+        moving_var_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving
+            variance. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
-        use_batch_statistics (bool): If ``true`` , use the mean value and variance value of current batch data. If
-            ``false`` , use the mean value and variance value of specified value. If ``None`` , training process will
-            use the mean and variance of current batch data and track the running mean and variance, eval process will
-            use the running mean and variance. Default: ``None`` .
-        process_groups (list): A list to divide devices into different sync groups, containing N subtraction lists.
-            Each subtraction list contains int numbers identifying rank ids which need to be synchronized in the same
-            group. All int values must be in [0, rank_size) and different from each other. Default: ``None`` ,
+        use_batch_statistics (bool, optional): If ``true`` , use the mean value and variance value of current batch
+            data. If ``false`` , use the mean value and variance value of specified value. If ``None`` , training
+            process will use the mean and variance of current batch data and track the running mean and variance, eval
+            process will use the running mean and variance. Default: ``None`` .
+        process_groups (list, optional): A list to divide devices into different sync groups, containing N subtraction
+            lists. Each subtraction list contains int numbers identifying rank ids which need to be synchronized in the
+            same group. All int values must be in [0, rank_size) and different from each other. Default: ``None`` ,
             indicating synchronization across all devices.
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
@@ -558,14 +563,14 @@ class SyncBatchNorm(_BatchNorm):
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
             Please see the `Ascend tutorial
-            <https://www.mindspore.cn/docs/en/master/model_train/parallel/rank_table.html>`_
+            <https://www.mindspore.cn/tutorials/en/master/parallel/rank_table.html>`_
             for more details.
 
             For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
-            <https://www.mindspore.cn/docs/en/master/model_train/parallel/mpirun.html>`_ .
+            <https://www.mindspore.cn/tutorials/en/master/parallel/mpirun.html>`_ .
 
             For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
-            Startup <https://www.mindspore.cn/docs/en/master/model_train/parallel/dynamic_cluster.html>`_ .
+            Startup <https://www.mindspore.cn/tutorials/en/master/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with multiple devices.
 
@@ -987,8 +992,8 @@ class InstanceNorm1d(_InstanceNorm):
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
         ValueError: If the shape of `gamma_init` / `beta_init` is not :math:`(C)`.
-        KeyError: If any of `gamma_init`/`beta_init` is str and the homonymous class inheriting from `Initializer` not
-            exists.
+        KeyError: If any of `gamma_init`/`beta_init` is str and
+            there is no homonymous class inheriting from `Initializer`.
 
     Supported Platforms:
         ``GPU``
@@ -1065,8 +1070,8 @@ class InstanceNorm2d(_InstanceNorm):
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
         ValueError: If the shape of `gamma_init` / `beta_init` is not :math:`(C)`.
-        KeyError: If any of `gamma_init`/`beta_init` is str and the homonymous class inheriting from `Initializer` not
-            exists.
+        KeyError: If any of `gamma_init`/`beta_init` is str and
+            there is no homonymous class inheriting from `Initializer`.
 
     Supported Platforms:
         ``GPU``
@@ -1171,10 +1176,11 @@ class GroupNorm(Cell):
 
     Group Normalization is widely used in recurrent neural networks. It applies
     normalization on a mini-batch of inputs for each single training case as described
-    in the paper `Group Normalization <https://arxiv.org/pdf/1803.08494.pdf>`_. Group Normalization
-    divides the channels into groups and computes within each group the mean and variance for normalization,
-    and it performs very stable over a wide range of batch size. :math:`\gamma` and :math:`\beta` are trainable scale
-    and shift.
+    in the paper `Group Normalization <https://arxiv.org/pdf/1803.08494.pdf>`_.
+    Group Normalization
+    divides the channels into groups and computes within each group the mean and variance for normalization.
+    :math:`\gamma` and :math:`\beta` are scale
+    and shift values obtained by training learning.
     It can be described using the following formula:
 
     .. math::

mindspore/nn/layer/pooling.py

@@ -32,7 +32,7 @@ from mindspore.ops.auto_generate import avg_pool1d_ext
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
            'FractionalMaxPool3d', 'AdaptiveAvgPool1d', 'AdaptiveMaxPool1d', 'AdaptiveMaxPool2d', 'AdaptiveMaxPool3d',
            'AdaptiveAvgPool2d', 'AdaptiveAvgPool3d', 'MaxUnpool1d', 'MaxUnpool2d', 'MaxUnpool3d', 'LPPool1d',
-           'LPPool2d', 'AvgPool2dExt', 'MaxPool2dExt', 'AvgPool1dExt']
+           'LPPool2d', 'AvgPool2dExt', 'AvgPool3dExt', 'MaxPool2dExt', 'AvgPool1dExt']
 
 
 class _PoolNd(Cell):
@@ -299,11 +299,12 @@ class MaxPool3d(_PoolNd):
         For Atlas training series products, this interface is not supported.
 
     Args:
-        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
+        kernel_size (Union[int, tuple[int]], optional): The size of kernel used to take the maximum value,
             is an int number or a single element tuple that represents depth, height and width of the kernel, or a tuple
             of three int numbers that represent depth, height and width respectively.
             The value must be a positive integer. Default: ``1`` .
-        stride (Union[int, tuple[int]]): The moving stride of pooling operation, an int number or a single element tuple
+        stride (Union[int, tuple[int]], optional): The moving stride of pooling operation,
+            an int number or a single element tuple
             that represents the moving stride of pooling kernel in the directions of depth, height and the width,
             or a tuple of three int numbers that represent depth, height and width of movement respectively.
             The value must be a positive integer. If the value is None, the default value `kernel_size` is used.
@@ -324,18 +325,19 @@ class MaxPool3d(_PoolNd):
               in the depth, height and width dimension 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])): Pooling padding value. Default: ``0`` .
+        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value. Default: ``0`` .
             `padding` can only be an integer or a tuple/list containing one or three integers.
             If `padding` is an integer or a tuple/list containing one integer, it will be padded in six directions of
             front, back, top, bottom, left and right of the input. If `padding` is a tuple/list containing three
             integers, it will be padded in front and back of the input `padding[0]` times, up and down `padding[1]`
             times, and left and right of the input `padding[2]` times.
-        dilation (Union(int, tuple[int])): The spacing between the elements of the kernel in convolution,
+        dilation (Union(int, tuple[int]), optional): The spacing between the elements of the kernel in convolution,
             used to increase the receptive field of the pooling operation. If it is a tuple, it must contain one or
             three integers. Default: ``1`` .
-        return_indices (bool): If ``True`` , output is a Tuple of 2 Tensors, representing the maxpool result and where
+        return_indices (bool, optional): 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): If ``True``, use ceil to calculate output shape.
+        ceil_mode (bool, optional): If ``True``, use ceil to calculate output shape.
             If ``False``, use ceil to calculate output shape. Default: ``False`` .
 
     Inputs:
@@ -713,9 +715,9 @@ class MaxPool1d(_PoolNd):
         \text{input}(N_i, C_j, s_0 \times l + n)
 
     Args:
-        kernel_size (int): The size of kernel used to take the max value, Default: ``1`` .
-        stride (int): The distance of kernel moving, an int number that represents
-            the width of movement is stride, Default: ``1`` .
+        kernel_size (int, optional): The size of kernel used to take the max value. Default: ``1`` .
+        stride (int, optional): The distance of kernel moving, an int number that represents
+            the width of movement is stride. Default: ``1`` .
         pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
 
@@ -731,24 +733,25 @@ 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]), optional): 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,
+        dilation (Union(int, tuple[int]), optional): The spacing between the elements of the kernel in convolution,
             used to increase the receptive field of the pooling operation. If it is a tuple, its length can only be 1.
             Default: ``1`` .
-        return_indices (bool): If ``True`` , the function will return both the result of max pooling and the indices of
+        return_indices (bool, optional): If ``True`` , the function will return
+            both the result of max pooling and the indices of
             the max elements. Default: ``False`` .
-        ceil_mode (bool): If True, use ceil to compute the output shape instead of floor. Default: ``False`` .
+        ceil_mode (bool, optional): If True, use ceil to compute the output shape instead of floor. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
 
     Outputs:
-        If `return_indices` is False, output is a Tensor, with shape :math:`(N, C_{out}, L_{out})` or
+        If `return_indices` is ``False``, output is a Tensor, with shape :math:`(N, C_{out}, L_{out})` or
         :math:`(C_{out}, L_{out})`. It has the same data type as `x`.
 
-        If `return_indices` is True, output is a Tuple of 2 Tensors, representing the maxpool result and where
+        If `return_indices` is ``True``, output is a Tuple of 2 Tensors, representing the maxpool result and where
         the max values are generated.
 
         - **output** (Tensor) - Maxpooling result, with shape :math:`(N, C_{out}, L_{out})` or
@@ -1021,6 +1024,47 @@ class AvgPool3d(_PoolNd):
         return out
 
 
+class AvgPool3dExt(Cell):
+    r"""
+    Applies a 3D average pooling over an input Tensor which can be regarded as
+    a composition of 3D input planes.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    For details, please refer to :func:`mindspore.mint.nn.functional.avg_pool3d`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> pool = ms.nn.AvgPool3dExt(kernel_size=3, stride=1)
+        >>> x = ms.ops.randn(1, 2, 4, 4, 5).astype(ms.float32)
+        >>> output = pool(x)
+        >>> print(output.shape)
+        (1, 2, 2, 2, 3)
+        >>> x1 = ms.ops.randn(6, 5, 7, 7, 5).astype(ms.float32)
+        >>> pool2 = ms.nn.AvgPool3dExt(4, stride=2, padding=(2, 2, 1), divisor_override=10)
+        >>> output2 = pool2(x1)
+        >>> print(output2.shape)
+        (6, 5, 4, 4, 2)
+    """
+    def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
+                 count_include_pad=True, divisor_override=None):
+        super(AvgPool3dExt, self).__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+        self.ceil_mode = ceil_mode
+        self.count_include_pad = count_include_pad
+        self.divisor_override = divisor_override
+
+    def construct(self, input):
+        return ops.function.nn_func.avg_pool3d_ext(input, self.kernel_size, self.stride, self.padding,
+                                                   self.ceil_mode, self.count_include_pad, self.divisor_override)
+
+
 class AvgPool1dExt(Cell):
     r"""
     Applies a 1D average pooling over an input Tensor which can be regarded as
@@ -1270,8 +1314,8 @@ class AvgPool1d(_PoolNd):
         This interface currently does not support Atlas A2 training series products.
 
     Args:
-        kernel_size (int): The size of kernel window used to take the average value, Default: ``1`` .
-        stride (int): The distance of kernel moving, an int number that represents
+        kernel_size (int, optional): The size of kernel window used to take the average value, Default: ``1`` .
+        stride (int, optional): The distance of kernel moving, an int number that represents
             the width of movement is strides, Default: ``1`` .
         pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
@@ -1282,17 +1326,20 @@ class AvgPool1d(_PoolNd):
               uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
               If this mode is set, `padding` must be 0.
             - ``"valid"``: No padding is applied to the input, and the output returns the maximum
-              possible length. Extra pixels that could not complete a full stride will
-              be discarded. If this mode is set, `padding` must be 0.
+              possible length. If a full stride cannot be formed, the extra pixels will be discarded.
+              If this mode is set, `padding` must be 0.
             - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
               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])): Pooling padding value, only ``"pad"`` mode can be set to non-zero.
+        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value,
+            only ``"pad"`` mode can be set to non-zero.
             Default: ``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.
-        ceil_mode (bool): If ``True`` , use ceil to compute the output shape instead of floor. Default: ``False`` .
-        count_include_pad (bool): If ``True`` , averaging calculation will include the zero-padding. Default: ``True`` .
+        ceil_mode (bool, optional): If ``True`` , use ceil to compute the output shape instead of floor.
+            Default: ``False`` .
+        count_include_pad (bool, optional): If ``True`` , averaging calculation will include the zero-padding.
+            Default: ``True`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
@@ -1728,13 +1775,14 @@ class AdaptiveMaxPool2d(Cell):
         \end{align}
 
     Note:
-        Ascend platform only supports float16 type for input.
+        In KBK mode, `output_size` does not support mutable.
 
     Args:
         output_size (Union[int, tuple]): The target output size. `output_size` can be a tuple :math:`(H, W)`,
             or an int H for :math:`(H, H)`. :math:`H` and :math:`W` can be int or None.
             If it is None, it means the output size is the same as the input size.
-        return_indices (bool): If `return_indices` is ``True`` , the indices of max value would be output.
+        return_indices (bool, optional): Whether to output the index of the maximum value.
+            If `return_indices` is ``True`` , the indices of max value would be output.
             Default: ``False`` .
 
     Inputs:
@@ -1797,15 +1845,11 @@ class AdaptiveMaxPool2d(Cell):
     def __init__(self, output_size, return_indices=False):
         """Initialize AdaptiveMaxPool2d."""
         super(AdaptiveMaxPool2d, self).__init__()
-        validator.check_value_type('return_indices', return_indices, [bool], self.cls_name)
-        self.adaptive_max_pool2d = ops.AdaptiveMaxPool2D(output_size)
+        self.output_size = output_size
         self.return_indices = return_indices
 
     def construct(self, input):
-        output = self.adaptive_max_pool2d(input)
-        if self.return_indices:
-            return output
-        return output[0]
+        return ops.adaptive_max_pool2d(input, self.output_size, self.return_indices)
 
 
 class AdaptiveMaxPool3d(Cell):

mindspore/nn/layer/transformer.py

@@ -54,16 +54,16 @@ class MultiheadAttention(Cell):
         embed_dim (int): Total dimension of MultiheadAttention.
         num_heads (int): Number of attention heads. Note that `embed_dim` will be split
             across `num_heads` (i.e. each head will have dimension `embed_dim // num_heads`).
-        dropout (float): Dropout probability of `attn_output_weights`. Default: ``0.0``.
-        has_bias (bool): Whether adds bias to input / output projection layers. Default: ``True``.
-        add_bias_kv (bool): Whether adds bias to the key and value sequences at axis=0. Default: ``False``.
-        add_zero_attn (bool): Whether adds a new batch of zeros to the key and value sequences at axis=1.
+        dropout (float, optional): Dropout probability of `attn_output_weights`. Default: ``0.0``.
+        has_bias (bool, optional): Whether adds bias to input / output projection layers. Default: ``True``.
+        add_bias_kv (bool, optional): Whether adds bias to the key and value sequences at axis=0. Default: ``False``.
+        add_zero_attn (bool, optional): Whether adds a new batch of zeros to the key and value sequences at axis=1.
             Default: ``False``.
-        kdim (int): Total number of features for keys. Default: ``None`` (`kdim=embed_dim`).
-        vdim (int): Total number of features for values. Default: ``None`` (`vdim=embed_dim`).
-        batch_first (bool): If ``True``, then the input and output shape are :math:`(batch, seq, feature)` ,
+        kdim (int, optional): Total number of features for keys. Default: ``None`` (`kdim=embed_dim`).
+        vdim (int, optional): Total number of features for values. Default: ``None`` (`vdim=embed_dim`).
+        batch_first (bool, optional): If ``True``, then the input and output shape are :math:`(batch, seq, feature)` ,
             else :math:`(seq, batch, feature)` . Default: ``False``.
-        dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Data type of Parameter. Default: ``mstype.float32`` .
 
     Inputs:
         - **query** (Tensor) - The query embeddings. If `query` is unbatched, the shape is :math:`(L, E_q)`,
@@ -85,7 +85,7 @@ class MultiheadAttention(Cell):
           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, optional) - 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.
           Must be of shape :math:`(L, S)` or :math:`(N\cdot\text{num_heads}, L, S)`, where :math:`N` is the
@@ -94,7 +94,8 @@ class MultiheadAttention(Cell):
           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, optional) - 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)
 

mindspore/nn/learning_rate_schedule.py

@@ -80,7 +80,8 @@ class ExponentialDecayLR(LearningRateSchedule):
         learning_rate (float): The initial value of learning rate.
         decay_rate (float): The decay rate.
         decay_steps (int): Number of steps to decay over.
-        is_stair (bool): If true, learning rate is decayed once every `decay_steps` time. Default: ``False`` .
+        is_stair (bool, optional): If ``True``, learning rate is decayed once every `decay_steps` time.
+            Default: ``False`` .
 
     Inputs:
         - **global_step** (Tensor) - The current step number. :math:`current\_step` in the above formula.
@@ -223,7 +224,8 @@ class InverseDecayLR(LearningRateSchedule):
         learning_rate (float): The initial value of learning rate.
         decay_rate (float): The decay rate.
         decay_steps (int): Number of steps to decay over.
-        is_stair (bool): If true, learning rate decay once every `decay_steps` times. If False, the learning rate
+        is_stair (bool, optional): If true, learning rate decay once every `decay_steps` times.
+            If False, the learning rate
             decays for every step. Default: ``False`` .
 
     Inputs:

mindspore/nn/loss/loss.py

@@ -127,7 +127,8 @@ class LossBase(Cell):
         Args:
             x (Tensor): Tensor of shape :math:`(N, *)` where :math:`*` means, any number of
                 additional dimensions.
-            weights (Union[float, Tensor]): Optional `Tensor` whose rank is either 0, or the same rank as inputs,
+            weights (Union[float, Tensor], optional): Weights. When `weights` is a Tensor,
+                the rank is either 0, or the same rank as inputs,
                 and must be broadcastable to inputs (i.e., all dimensions must be either `1`,
                 or the same as the corresponding inputs dimension). Default: ``1.0`` .
 
@@ -617,7 +618,8 @@ class MarginRankingLoss(LossBase):
 
 class SmoothL1Loss(LossBase):
     r"""
-    SmoothL1 loss function, if the absolute error element-wise between the predicted value and the target value
+    SmoothL1 loss function. Compare the error value element-wise and
+    if the absolute error between the predicted value and the target value
     is less than the set threshold `beta`, the square term is used, otherwise the absolute error term is used.
 
     Given two input :math:`x,\  y`, the SmoothL1Loss can be described as follows:
@@ -667,11 +669,13 @@ class SmoothL1Loss(LossBase):
 
           - Ascend: float16, float32, bfloat16.
           - CPU/GPU: float16, float32, float64.
+
         - **labels** (Tensor) - Ground truth data.
 
           - CPU/Ascend: has the same shape as the `logits`,
             `logits` and `labels` comply with the implicit type conversion rules to make the data types consistent.
           - GPU: has the same shape and dtype as the `logits`.
+
     Outputs:
         Tensor, if `reduction` is ``'none'``, then output is a tensor with the same shape as `logits`.
         Otherwise the shape of output tensor is :math:`()`.
@@ -732,16 +736,19 @@ class SoftMarginLoss(LossBase):
             - ``'sum'``: the output elements will be summed.
 
     Inputs:
-        - **logits** (Tensor) - Predict data. Data type must be float16 or float32.
-        - **labels** (Tensor) - Ground truth data, with the same type and shape as `logits`.
+        - **logits** (Tensor) - Predict data. Data type must be float16, float32,
+          bfloat16 (Among them, the Atlas training series products do not support bfloat16).
+        - **labels** (Tensor) - Ground truth data, with the same shape as `logits`.
+          In GE mode, the data type should be the same as `logits`.
 
     Outputs:
-        Tensor or Scalar, if `reduction` is ``"none"``, its shape is the same as `logits`.
+        Tensor or Scalar, if `reduction` is ``'none'``, its shape is the same as `logits`.
         Otherwise, a scalar value will be returned.
 
     Raises:
         TypeError: If `logits` or `labels` is not a Tensor.
-        TypeError: If dtype of `logits` or `labels` is neither float16 nor float32.
+        TypeError: If dtype of `logits` or `labels` is not float16, float32,
+                   bfloat16 (Among them, the Atlas training series products do not support bfloat16).
         ValueError: If shape of `logits` is not the same as `labels`.
         ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
@@ -762,10 +769,10 @@ class SoftMarginLoss(LossBase):
 
     def __init__(self, reduction='mean'):
         super(SoftMarginLoss, self).__init__()
-        self.soft_margin_loss = P.SoftMarginLoss(reduction)
+        self.reduction = reduction
 
     def construct(self, logits, labels):
-        return self.soft_margin_loss(logits, labels)
+        return F.soft_margin_loss(logits, labels, self.reduction)
 
 
 class SoftmaxCrossEntropyWithLogits(LossBase):
@@ -813,8 +820,8 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
 
     Raises:
         TypeError: If `sparse` is not a bool.
-        TypeError: If `sparse` is True and dtype of `labels` is neither int32 nor int64.
-        TypeError: If `sparse` is False and dtype of `labels` is neither float16 not float32.
+        TypeError: If `sparse` is ``True`` and dtype of `labels` is neither int32 nor int64.
+        TypeError: If `sparse` is ``False`` and dtype of `labels` is neither float16 not float32.
         ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
 
     Supported Platforms:
@@ -893,8 +900,8 @@ class DiceLoss(LossBase):
     :math:`pred` represent `logits`, :math:`true` represent `labels` .
 
     Args:
-        smooth (float): A term added to the denominator to improve numerical stability. Should be greater than 0.
-                        Default: ``1e-5`` .
+        smooth (float, optional): A term added to the denominator to improve numerical stability.
+            Should be greater than 0. Default: ``1e-5`` .
 
     Inputs:
         - **logits** (Tensor) - Input predicted value. The data type must be float16 or float32.
@@ -938,11 +945,12 @@ class DiceLoss(LossBase):
         if label.dtype == mstype.uint8:
             raise TypeError(f"For '{self.cls_name}', the dtype of 'labels' can not be uint8.")
         intersection = self.reduce_sum(self.mul(logits.view(-1), label.view(-1)))
-        unionset = self.reduce_sum(self.mul(logits.view(-1), logits.view(-1))) + \
-                   self.reduce_sum(self.mul(label.view(-1), label.view(-1)))
+        unionset_part1 = self.reduce_sum(self.mul(logits.view(-1), logits.view(-1)))
+        unionset_part2 = self.reduce_sum(self.mul(label.view(-1), label.view(-1)))
+        unionset = ops.add(unionset_part1, unionset_part2)
 
-        single_dice_coeff = (2 * intersection) / (unionset + self.smooth)
-        dice_loss = 1 - single_dice_coeff
+        single_dice_coeff = (2 * intersection) / ops.add(unionset, self.smooth)
+        dice_loss = ops.sub(1, single_dice_coeff)
 
         return dice_loss
 
@@ -1058,7 +1066,7 @@ class MultiClassDiceLoss(LossBase):
                 dice_loss = self.binarydiceloss(logits[:, i], label[:, i])
                 if self.weights is not None:
                     _check_weights(self.weights.shape[0], label.shape[1], self.cls_name)
-                    dice_loss *= self.weights[i]
+                    dice_loss = dice_loss * self.weights[i]
                 total_loss += dice_loss
 
         return total_loss / label.shape[1]
@@ -2571,7 +2579,7 @@ class KLDivLoss(LossBase):
     the updating formulas of KLDivLoss algorithm are as follows,
 
     .. math::
-        L(x, target) = target \cdot (\log target - x)
+        L(x, target) = target \cdot (\log target - \log x)
 
     Then,
 
@@ -2865,7 +2873,7 @@ class HingeEmbeddingLoss(LossBase):
     where :math:`L = \{l_1,\dots,l_N\}^\top`.
 
     Args:
-        margin (float, int): Threshold defined by Hinge Embedding Loss :math:`margin`.
+        margin (float, int, optional): Threshold defined by Hinge Embedding Loss :math:`margin`.
             Represented as :math:`\Delta` in the formula. Default: ``1.0`` .
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
             ``'sum'`` . Default: ``'mean'`` .

mindspore/nn/optim/ada_grad.py

@@ -113,8 +113,8 @@ class Adagrad(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        accum (float): The starting value for :math:`h`, must be zero or positive values. Default: ``0.1`` .
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``0.001`` .
+        accum (float, optional): The starting value for :math:`h`, must be zero or positive values. Default: ``0.1`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``0.001`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -130,13 +130,14 @@ class Adagrad(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        update_slots (bool): Whether the :math:`h` will be updated. Default: ``True`` .
-        loss_scale (float): Value for the loss scale. It must be greater than 0.0. In general, use the default value.
+        update_slots (bool, optional): Whether the :math:`h` will be updated. Default: ``True`` .
+        loss_scale (float, optional): Value for the loss scale. It must be greater than 0.0. In general,
+            use the default value.
             Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to False, then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
             Default: ``1.0`` .
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.