mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/include/api/status.h

@@ -128,75 +128,37 @@ enum StatusCode : uint32_t {
 
 class MS_API Status {
  public:
-  /// \brief Constructor of Status.
   Status();
-  /// \brief Constructor of Status.
-  ///
-  /// \param[in] status_code Status code.
-  ///
-  /// \param[in] status_msg Status message.
   inline Status(enum StatusCode status_code, const std::string &status_msg = "");  // NOLINT(runtime/explicit)
-  /// \brief Constructor of Status.
   inline Status(const StatusCode code, int line_of_code, const char *file_name, const std::string &extra = "");
-  /// \brief Destructor of Status.
+
   ~Status() = default;
-  /// \brief Status code of status.
-  ///
-  /// \return Enum of status code.
+
   enum StatusCode StatusCode() const;
-  /// \brief Exchange status to string.
-  ///
-  /// \return Status code exchanged to string.
   inline std::string ToString() const;
-  /// \brief Get line of status code.
-  ///
-  /// \return Line of code to get.
+
   int GetLineOfCode() const;
-  /// \brief Get file name of status.
-  ///
-  /// \return File name to get.
   inline std::string GetFileName() const;
-  /// \brief Get error description of status.
-  ///
-  /// \return Error description to get.
   inline std::string GetErrDescription() const;
-  /// \brief Get error description of status.
-  ///
-  /// \param[in] err_description Error description to be set.
   inline std::string SetErrDescription(const std::string &err_description);
-  /// \brief Status message to be set.
-  ///
-  /// \param[in] status_msg Status message to be set.
   inline void SetStatusMsg(const std::string &status_msg);
-  /// \brief Operator <<.
+
   MS_API friend std::ostream &operator<<(std::ostream &os, const Status &s);
-  /// \brief Operator ==.
+
   bool operator==(const Status &other) const;
-  /// \brief Operator ==.
   bool operator==(enum StatusCode other_code) const;
-  /// \brief Operator !=.
   bool operator!=(const Status &other) const;
-  /// \brief Operator !=.
   bool operator!=(enum StatusCode other_code) const;
-  /// \brief Operator bool().
+
   explicit operator bool() const;
-  /// \brief Operator int().
   explicit operator int() const;
-  /// \brief Getting back the status of OK.
-  ///
-  /// \return Status Code of ok.
+
   static Status OK();
-  /// \brief Getting back if it is ok.
-  ///
-  /// \return True if it is ok.
+
   bool IsOk() const;
-  /// \brief Getting back if it is error.
-  ///
-  /// \return True if it is error.
+
   bool IsError() const;
-  /// \brief Getting back the code as string.
-  ///
-  /// \return The code name as string type.
+
   static inline std::string CodeAsString(enum StatusCode c);
 
  private:

mindspore/include/api/types.h

@@ -74,7 +74,6 @@ class Allocator;
 /// \brief The MSTensor class defines a tensor in MindSpore.
 class MS_API MSTensor {
  public:
-  /// \brief Impl class of MSTensor.
   class Impl;
   /// \brief Creates a MSTensor object, whose data need to be copied before accessed by Model, must be used in pairs
   /// with DestroyTensorPtr.
@@ -162,17 +161,13 @@ class MS_API MSTensor {
   ///
   /// \param[in] tensor A MSTensor object.
   static void DestroyTensorPtr(MSTensor *tensor) noexcept;
-  /// \brief Constructor of MSTensor.
+
   MSTensor();
-  /// \brief Constructor of MSTensor.
   explicit MSTensor(const std::shared_ptr<Impl> &impl);
-  /// \brief Constructor of MSTensor.
   // if malloc data, user need to free after constructing MSTensor, else memory leak.
   inline MSTensor(const std::string &name, DataType type, const std::vector<int64_t> &shape, const void *data,
                   size_t data_len);
-  /// \brief Constructor of MSTensor.
   explicit MSTensor(std::nullptr_t);
-  /// \brief Destructor of MSTensor.
   ~MSTensor();
 
   /// \brief Obtains the name of the MSTensor.

mindspore/include/dataset/constants.h

@@ -356,15 +356,6 @@ constexpr int32_t kMaxLegalPort = 65535;
 // Invalid OpenCV type should not be from 0 to 7 (opencv4/opencv2/core/hal/interface.h)
 constexpr uint8_t kCVInvalidType = 255;
 
-constexpr size_t dimension_zero = 0;
-constexpr size_t dimension_one = 1;
-constexpr size_t dimension_two = 2;
-constexpr size_t dimension_three = 3;
-constexpr size_t size_one = 1;
-constexpr size_t size_two = 2;
-constexpr size_t size_three = 3;
-constexpr size_t size_four = 4;
-
 using connection_id_type = uint64_t;
 using session_id_type = uint32_t;
 using row_id_type = int64_t;

mindspore/mindrecord/tools/cifar10.py

@@ -40,8 +40,7 @@ class CifarMD5Validator:
                         'data_batch_5': '482c414d41f54cd18b22e5b47cb7c3cb',
                         'test_batch': '40351d587109b95175f43aff81a1287e'}
 
-    @staticmethod
-    def calculate_md5(file_path):
+    def calculate_md5(self, file_path):
         """
         Calculate MD5 hash of a file.
 
@@ -77,7 +76,7 @@ class CifarMD5Validator:
             KeyError: If file_name is not found in md5_map.
         """
         expected_md5 = self.md5_map.get(file_name)
-        actual_md5 = CifarMD5Validator.calculate_md5(os.path.join(file_path, file_name))
+        actual_md5 = self.calculate_md5(os.path.join(file_path, file_name))
 
         if actual_md5 is None or expected_md5 is None or actual_md5 != expected_md5:
             logger.warning(f"The MD5 value of {file_name} does not match the official CIFAR10 file."

mindspore/mindrecord/tools/cifar10_to_mr.py

@@ -49,6 +49,11 @@ class Cifar10ToMR:
         >>> mindrecord_file = "/path/to/mindrecord/file"
         >>> cifar10_to_mr = Cifar10ToMR(cifar10_dir, mindrecord_file)
         >>> cifar10_to_mr.transform()
+
+    .. warning::
+        Cifar10ToMR.transform() uses `pickle` module implicitly, which is known to be insecure.
+        It is possible to construct malicious pickle data which will execute arbitrary code during unpickling.
+        Never load data that could have come from an untrusted source, or that could have been tampered with.
     """
 
     def __init__(self, source, destination):
@@ -107,11 +112,6 @@ class Cifar10ToMR:
         Note:
             Please refer to the Examples of :class:`mindspore.mindrecord.Cifar10ToMR` .
 
-        .. warning::
-            `Cifar10ToMR.transform()` uses `pickle` module implicitly, which is known to be insecure.
-            It is possible to construct malicious pickle data which will execute arbitrary code during unpickling.
-            Never load data that could have come from an untrusted source, or that could have been tampered with.
-
         Args:
             fields (list[str], optional): A list of index fields. Default: ``None`` . For index field settings,
                 please refer to :func:`mindspore.mindrecord.FileWriter.add_index` .

mindspore/mint/distributed/__init__.py

@@ -37,11 +37,9 @@ from mindspore.mint.distributed.distributed import (
     get_group_rank,
     all_reduce,
     all_gather_into_tensor,
-    all_gather_into_tensor_uneven,
     all_to_all,
     all_to_all_single,
     reduce_scatter_tensor,
-    reduce_scatter_tensor_uneven,
     isend,
     irecv,
     send,
@@ -75,11 +73,9 @@ __all__ = [
     "get_group_rank",
     "all_reduce",
     "all_gather_into_tensor",
-    "all_gather_into_tensor_uneven",
     "all_to_all",
     "all_to_all_single",
     "reduce_scatter_tensor",
-    "reduce_scatter_tensor_uneven",
     "isend",
     "irecv",
     "send",

mindspore/mint/distributed/distributed.py

@@ -58,11 +58,9 @@ from mindspore.ops.auto_generate.gen_ops_prim import (
     dist_comm_isend_op,
     dist_comm_all_to_all_v_op,
     dist_comm_reduce_scatter_tensor_op,
-    dist_comm_reduce_scatter_tensor_uneven_op,
     dist_comm_all_to_all_v_single_op,
     dist_comm_broadcast_op,
     dist_comm_all_gather_into_tensor_op,
-    dist_comm_all_gather_into_tensor_uneven_op,
     dist_comm_irecv_op,
     dist_comm_scatter_tensor_op,
     dist_comm_gather_into_tensor_op,
@@ -991,22 +989,6 @@ def _check_all_tensor_same_dtype_and_shape(*tensor_lists):
                     )
 
 
-@_primexpr
-def _check_output_shape(output, expected_shape, op_name):
-    if output.shape != expected_shape:
-        raise TypeError(
-            f"For {op_name}, the output shape should be {expected_shape}, "
-            f"but got {output.shape}.")
-
-
-@_primexpr
-def _check_output_dtype(output, expected_dtype, op_name):
-    if output.dtype != expected_dtype:
-        raise TypeError(
-            f"For {op_name}, the output dtype should be {expected_dtype}, "
-            f"but got {output.dtype}.")
-
-
 def all_reduce(tensor, op=ReduceOp.SUM, group=None, async_op=False):
     """
     Reduce tensors across all devices in such a way that all deviceswill get the same final result,
@@ -1171,91 +1153,6 @@ def all_gather_into_tensor(output_tensor, input_tensor, group=None, async_op=Fal
     return handle
 
 
-def all_gather_into_tensor_uneven(output, input, output_split_sizes=None, group=None, async_op=False):
-    r"""
-    Gathers and concatenates tensors across devices with uneven first dimensions.
-
-    Note:
-        - Input tensors must have identical shapes except for the first dimension.
-        - Output tensor's first dimension should equal to the sum of all devices' input first dimensions.
-
-    Args:
-        output (Tensor): Concatenated output tensor with shape :math:`(\sum_{i=0}^{N-1} x_{i1}, x_2, ..., x_R)`,
-            where N is the number of devices in the group.
-        input (Tensor): Local input tensor with shape :math:`(x_{k1}, x_2, ..., x_R)`, where k is current device's rank.
-        output_split_sizes (list[int], optional): Specifies first dimension sizes from each device.
-            Must match actual input dimensions when provided.
-            If ``None``, assumes equal split sizes across devices. Default: ``None``.
-        group (str, optional): The communication group to work on. If ``None``,
-            which means ``"hccl_world_group"`` in Ascend. Default: ``None``.
-        async_op (bool, optional): Whether this operator should be an async operator. Default: ``False``.
-
-    Returns:
-        CommHandle, CommHandle is an async work handle, if `async_op` is set to True.
-        CommHandle will be None, when `async_op` is False.
-
-    Raises:
-        ValueError: If the shape of `input` does not match the constraints of `output_split_sizes`.
-        RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        .. note::
-            Before running the following examples, you need to configure the communication environment variables.
-
-            For Ascend devices, it is recommended to use the msrun startup method
-            without any third-party or configuration file dependencies.
-            Please see the `msrun start up
-            <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
-            for more details.
-
-            This example should be run with 2 devices.
-
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> from mindspore.mint.distributed import init_process_group, get_rank
-        >>> from mindspore.mint.distributed import all_gather_into_tensor_uneven
-        >>> from mindspore import Tensor
-        >>>
-        >>> ms.set_device(device_target="Ascend")
-        >>> init_process_group()
-        >>> if get_rank() == 0:
-        >>>     input_tensor = Tensor(np.ones([3, 4]).astype(np.float32))
-        >>> else:
-        >>>     input_tensor = Tensor(np.ones([2, 4]).astype(np.float32))
-        >>> out_tensor = Tensor(np.zeros([5, 4]).astype(np.float32))
-        >>> output_split_sizes = [3, 2]
-        >>> output = all_gather_into_tensor_uneven(out_tensor, input_tensor, output_split_sizes)
-        >>> print(out_tensor)
-        [[1. 1. 1. 1.]
-         [1. 1. 1. 1.]
-         [1. 1. 1. 1.]
-         [1. 1. 1. 1.]
-         [1. 1. 1. 1.]]
-    """
-    if group is None:
-        group = GlobalComm.WORLD_COMM_GROUP
-    if not isinstance(group, str):
-        raise TypeError(
-            "The argument 'group' must be type of string, "
-            "but got 'group' type : {}.".format(type(group))
-        )
-    if not isinstance(async_op, bool):
-        raise TypeError(
-            f"The argument 'async_op' must be a bool, but got {type(async_op)}."
-        )
-    group_size = get_cache_group_size(group)
-    output_split_sizes = [] if output_split_sizes is None else output_split_sizes
-    result = dist_comm_all_gather_into_tensor_uneven_op(
-        output, input, output_split_sizes, group_size, group
-    )
-    _, handle = _deal_comm_outputs(result, async_op)
-    return handle
-
-
 def reduce_scatter_tensor(output, input, op=ReduceOp.SUM, group=None, async_op=False):
     r"""
     Reduces and scatters tensors from the specified communication group and
@@ -1346,101 +1243,6 @@ def reduce_scatter_tensor(output, input, op=ReduceOp.SUM, group=None, async_op=F
     return handle
 
 
-def reduce_scatter_tensor_uneven(output, input, input_split_sizes=None, op=ReduceOp.SUM, group=None, async_op=False):
-    r"""
-    Reduce tensors from the specified communication group and scatter to the output tensor
-    according to `input_split_sizes`.
-
-    Note:
-        - The input tensor must have identical shape and format across all processes.
-        - The first dimension of input tensor should equal to the sum of `input_split_sizes`.
-
-    Args:
-        output(Tensor): the output tensor has the same dtype as `input` with a shape of
-            :math:`(input_split_sizes[rank], *)`, where rank is the local rank id of the device.
-        input(Tensor): The input tensor to be reduced and scattered, Expected shape :math:`(N, *)`, where `*`
-            means any number of additional dimensions. N must equal the sum of `input_split_sizes` across ranks.
-        input_split_sizes (list[int], optional): List specifying how to split the first dimension of input tensor.
-            If ``None``, splits evenly according to group size. Default: ``None``.
-        op (str, optional): Specifies an operation used for element-wise reductions,
-            One of ReduceOp: 'SUM', 'MIN', 'MAX'. Default: ``ReduceOp.SUM``.
-        group (str, optional): The communication group to work on. If ``None``, which means ``"hccl_world_group"`` in
-            Ascend. Default: ``None``.
-        async_op (bool, optional): Whether this operator should be an async operator. Default: ``False``.
-
-    Returns:
-        CommHandle, CommHandle is an async work handle, if `async_op` is set to True.
-        CommHandle will be None, when `async_op` is False.
-
-    Raises:
-        ValueError: If the shape of `output` does not match the constraints of `input_split_sizes`.
-        RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        .. note::
-            Before running the following examples, you need to configure the communication environment variables.
-
-            For Ascend devices, it is recommended to use the msrun startup method
-            without any third-party or configuration file dependencies.
-            Please see the `msrun start up
-            <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
-            for more details.
-
-            This example should be run with 2 devices.
-
-        >>> import mindspore as ms
-        >>> from mindspore import Tensor
-        >>> from mindspore.mint.distributed import init_process_group, get_rank
-        >>> from mindspore.mint.distributed import reduce_scatter_tensor_uneven
-        >>> import numpy as np
-        >>>
-        >>> ms.set_device(device_target="Ascend")
-        >>> init_process_group()
-        >>> input_tensor = Tensor(np.ones([5, 8]).astype(np.float32))
-        >>> if get_rank() == 0:
-        >>>     output_tensor = Tensor(np.ones([2, 8]).astype(np.float32))
-        >>> else:
-        >>>     output_tensor = Tensor(np.ones([3, 8]).astype(np.float32))
-        >>> input_split_sizes = [2, 3]
-        >>> output = reduce_scatter_tensor_uneven(output_tensor, input_tensor, input_split_sizes)
-        >>> print(output_tensor)
-        rank 0:
-        [[2. 2. 2. 2. 2. 2. 2. 2.]
-         [2. 2. 2. 2. 2. 2. 2. 2.]]
-        rank 1:
-        [[2. 2. 2. 2. 2. 2. 2. 2.]
-         [2. 2. 2. 2. 2. 2. 2. 2.]
-         [2. 2. 2. 2. 2. 2. 2. 2.]]
-    """
-    if not isinstance(op, str):
-        raise TypeError("For reduce_scatter_tensor_uneven, the input op type must be str")
-    if op not in ("sum", "min", "max"):
-        raise TypeError(
-            "For reduce_scatter_tensor_uneven, the input op value must be one of sum, prod, min, max"
-        )
-    if group is None:
-        group = GlobalComm.WORLD_COMM_GROUP
-    if not isinstance(group, str):
-        raise TypeError(
-            "The argument 'group' must be type of string, "
-            "but got 'group' type : {}.".format(type(group))
-        )
-    if not isinstance(async_op, bool):
-        raise TypeError(
-            f"The argument 'async_op' must be a bool, but got {type(async_op)}."
-        )
-    input_split_sizes = [] if input_split_sizes is None else input_split_sizes
-    rank_size = get_cache_group_size(group)
-    result = dist_comm_reduce_scatter_tensor_uneven_op(
-        output, input, input_split_sizes, rank_size, op, group
-    )
-    _, handle = _deal_comm_outputs(result, async_op)
-    return handle
-
-
 def reduce(tensor, dst, op=ReduceOp.SUM, group=None, async_op=False):
     """
     Reduces tensors across the processes in the specified communication group, sends the result
@@ -2584,7 +2386,10 @@ def all_to_all_single(output,
 
 def _check_tensor_list(tensor_list, tensor, group_size):
     """check all elements in tensor_list are type of Tensor or tuple or list"""
-    _check_group_tensor_list(tensor_list, group_size)
+    if not tensor_list or len(tensor_list) != group_size:
+        raise TypeError(
+            f"The argument list tensor len must be equal to group rank size, but got {len(tensor_list)}."
+        )
     if tensor.dtype != tensor_list[0].dtype:
         raise TypeError(
             f"The argument list tensor type must be equal to tensor type, but got {tensor_list[0].dtype}."
@@ -2595,17 +2400,13 @@ def _check_tensor_list(tensor_list, tensor, group_size):
         )
 
 
-def _check_group_tensor_list(tensor_list, group_size):
-    if not tensor_list or len(tensor_list) != group_size:
-        raise TypeError(
-            f"The argument list tensor len must be equal to group rank size, but got {len(tensor_list)}."
-        )
-
-
 def all_gather(tensor_list, tensor, group=None, async_op=False):
     """
     Gathers tensors from the specified communication group and returns the tensor list which is all gathered.
 
+    Note:
+        The tensors must have the same shape and format in all processes of the collection.
+
     Args:
         tensor_list (list[Tensor]): Output list.
         tensor (Tensor): The input tensor to be all gathered into tensor.
@@ -2660,7 +2461,7 @@ def all_gather(tensor_list, tensor, group=None, async_op=False):
 
     """
     _check_all_tensors(tensor_list)
-    _check_all_tensor_same_dtype(tensor_list)
+    _check_all_tensor_same_dtype_and_shape(tensor_list)
     if not isinstance(tensor, (Tensor, Tensor_)):
         raise TypeError("For all_gather_into_tensor, the input tensor must be tensor")
     if group is None:
@@ -2675,10 +2476,7 @@ def all_gather(tensor_list, tensor, group=None, async_op=False):
             f"The argument 'async_op' must be a bool, but got {type(async_op)}."
         )
     group_size = get_cache_group_size(group)
-    _check_group_tensor_list(tensor_list, group_size)
-    rank_id = get_group_rank_from_world_rank(get_rank(), group)
-    _check_output_shape(tensor, tensor_list[rank_id].shape, "all_gather")
-    _check_output_dtype(tensor, tensor_list[0].dtype, "all_gather")
+    _check_tensor_list(tensor_list, tensor, group_size)
     result = dist_comm_all_gather_op(tensor_list, tensor, group_size, group)
     _, handle = _deal_comm_outputs(result, async_op)
     return handle
@@ -2689,6 +2487,9 @@ def reduce_scatter(output, input_list, op=ReduceOp.SUM, group=None, async_op=Fal
     Reduces and scatters tensors from the specified communication group and
     returns the tensor which is reduced and scattered.
 
+    Note:
+        The tensors must have the same shape and format in all processes of the collection.
+
     Args:
         output (Tensor): the output tensor.
         input_list (list[Tensor]): List of tensors to reduce and scatter.
@@ -2742,7 +2543,7 @@ def reduce_scatter(output, input_list, op=ReduceOp.SUM, group=None, async_op=Fal
     """
 
     _check_all_tensors(input_list)
-    _check_all_tensor_same_dtype(input_list)
+    _check_all_tensor_same_dtype_and_shape(input_list)
     if not isinstance(output, (Tensor, Tensor_)):
         raise TypeError("For reduce_scatter, the output tensor must be tensor")
     if group is None:
@@ -2763,11 +2564,7 @@ def reduce_scatter(output, input_list, op=ReduceOp.SUM, group=None, async_op=Fal
             "For reduce_scatter, the input op value must be one of sum, prod, min, max"
         )
     rank_size = get_cache_group_size(group)
-    _check_group_tensor_list(input_list, rank_size)
-
-    rank_id = get_group_rank_from_world_rank(get_rank(), group)
-    _check_output_shape(output, input_list[rank_id].shape, "reduce_scatter")
-    _check_output_dtype(output, input_list[0].dtype, "reduce_scatter")
+    _check_tensor_list(input_list, output, rank_size)
     result = dist_comm_reduce_scatter_op(output, input_list, rank_size, op, group)
     _, handle = _deal_comm_outputs(result, async_op)
     return handle

mindspore/mint/nn/layer/_functions.py

@@ -23,7 +23,7 @@ from mindspore.communication.management import get_rank, get_group_size, GlobalC
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormReduceGrad
 from mindspore.ops.auto_generate.gen_ops_prim import BatchNormElemtGrad
 from mindspore.ops.primitive import Primitive, prim_arg_register, PrimitiveWithInfer, prim_attr_register
-from mindspore.ops.operations.comm_ops import ReduceOp, check_collective_target_dtype
+from mindspore.ops.operations.comm_ops import ReduceOp, check_hcom_group_valid, check_collective_target_dtype
 
 batch_norm_reduce_grad = BatchNormReduceGrad()
 batch_norm_elemt_grad = BatchNormElemtGrad()
@@ -71,6 +71,7 @@ class AllReduce(Primitive):
         if not isinstance(self.group, str):
             raise TypeError(f"For '{self.name}', the 'group' must be str, "
                             f"but got {type(self.group).__name__}.")
+        check_hcom_group_valid(self.group, prim_name=self.name)
         self.op = op
         self.add_prim_attr('group', self.group)
         self.add_prim_attr('fusion', 0)

mindspore/mint/nn/layer/conv.py

@@ -200,6 +200,8 @@ class Conv1d(_Conv):
               possible length. Extra sequence that could not complete a full stride will
               be discarded.
 
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Specifies the dilation
             rate to use for dilated convolution.
             It can be a single int or a tuple/list of 1 integer. 
@@ -217,8 +219,6 @@ class Conv1d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv1d layer has a bias parameter. Default: ``True`` .
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:
@@ -393,6 +393,8 @@ class Conv2d(_Conv):
               possible height and width. Extra pixels that could not complete a full stride will
               be discarded.
 
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Specifies the dilation rate to use
             for dilated convolution.
             It can be a single int or a tuple/list of 2 integers. A single int means the dilation size is the same
@@ -413,8 +415,6 @@ class Conv2d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv2d layer has a bias parameter. Default: ``True`` .
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:
@@ -600,6 +600,8 @@ class Conv3d(_Conv):
               possible height and width. Extra pixels that could not complete a full stride will
               be discarded.
 
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dilation (Union[int, tuple[int], list[int]], optional): Controlling the space between the kernel points.
             Default: ``1`` .
         groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
@@ -613,8 +615,6 @@ class Conv3d(_Conv):
             - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv3d layer has a bias parameter. Default: ``True`` .
-        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
-            ``"zeros"`` , ``"reflect"`` or ``"replicate"`` . Default: ``"zeros"`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Variables:

mindspore/mint/nn/layer/normalization.py

@@ -218,7 +218,7 @@ class BatchNorm1d(_BatchNorm):
         dim = len(shape)
         if dim != 2 and dim != 3:
             raise ValueError(
-                "expected 2D or 3D input, but got " + str(dim) + "D input"
+                "expected 2D or 3D input (got {}D input)".format(dim)
             )
 
 
@@ -288,7 +288,7 @@ class BatchNorm2d(_BatchNorm):
         dim = len(shape)
         if dim != 4:
             raise ValueError(
-                "expected 4D input, but got " + str(dim) + "D input"
+                "expected 4D input (got {}D input)".format(dim)
             )
 
 
@@ -356,7 +356,7 @@ class BatchNorm3d(_BatchNorm):
         dim = len(shape)
         if dim != 5:
             raise ValueError(
-                "expected 5D input, but got " + str(dim) + "D input"
+                "expected 5D input (got {}D input)".format(dim)
             )