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

mindspore/nn/probability/bijector/power_transform.py

@@ -13,8 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """PowerTransform Bijector"""
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
+import mindspore.ops as ops
 from ..distribution._utils.utils import check_greater_equal_zero
 from ..distribution._utils.custom_ops import exp_generic, log_generic
 from .bijector import Bijector
@@ -76,16 +75,16 @@ class PowerTransform(Bijector):
         self._power = self._add_parameter(power, 'power')
         check_greater_equal_zero(self._power, 'Power')
 
-        self.pow = P.Pow()
-        self.dtypeop = P.DType()
-        self.cast = P.Cast()
-        self.equal_base = P.Equal()
+        self.pow = ops.Pow()
+        self.dtypeop = ops.DType()
+        self.cast = ops.Cast()
+        self.equal_base = ops.Equal()
         self.exp = exp_generic
-        self.expm1 = P.Expm1()
+        self.expm1 = ops.Expm1()
         self.log = log_generic
-        self.log1p = P.Log1p()
-        self.select_base = P.Select()
-        self.shape = P.Shape()
+        self.log1p = ops.Log1p()
+        self.select_base = ops.Select()
+        self.shape = ops.Shape()
 
     @property
     def power(self):
@@ -113,17 +112,17 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(x, self.power)
 
         # broad cast the value of x and power
-        ones = F.fill(self.dtypeop(power_local), self.shape(x + power_local),
-                      1.)
+        ones = ops.fill(self.dtypeop(power_local), self.shape(x + power_local),
+                        1.)
         power_local = power_local * ones
         x = x * ones
         safe_power = self.select_base(
             self.equal_base(power_local,
-                            P.ZerosLike()(power_local)), ones, power_local)
+                            ops.ZerosLike()(power_local)), ones, power_local)
 
         forward_v = self.select_base(
             self.equal_base(power_local,
-                            P.ZerosLike()(power_local)), self.exp(x),
+                            ops.ZerosLike()(power_local)), self.exp(x),
             self.exp(self.log1p(x * safe_power) / safe_power))
         return forward_v
 
@@ -135,17 +134,17 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(y, self.power)
 
         # broad cast the value of x and power
-        ones = F.fill(self.dtypeop(power_local), self.shape(y + power_local),
-                      1.)
+        ones = ops.fill(self.dtypeop(power_local), self.shape(y + power_local),
+                        1.)
         power_local = power_local * ones
         y = y * ones
         safe_power = self.select_base(
             self.equal_base(power_local,
-                            P.ZerosLike()(power_local)), ones, power_local)
+                            ops.ZerosLike()(power_local)), ones, power_local)
 
         inverse_v = self.select_base(
             self.equal_base(power_local,
-                            P.ZerosLike()(power_local)), self.log(y),
+                            ops.ZerosLike()(power_local)), self.log(y),
             self.expm1(self.log(y) * safe_power) / safe_power)
 
         return inverse_v
@@ -166,14 +165,14 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(x, self.power)
 
         # broad cast the value of x and power
-        ones = F.fill(self.dtypeop(power_local), self.shape(x + power_local),
-                      1.)
+        ones = ops.fill(self.dtypeop(power_local), self.shape(x + power_local),
+                        1.)
         power_local = power_local * ones
         x = x * ones
 
         forward_log_j = self.select_base(
             self.equal_base(power_local,
-                            P.ZerosLike()(power_local)), x,
+                            ops.ZerosLike()(power_local)), x,
             (1. / power_local - 1) * self.log1p(x * power_local))
 
         return forward_log_j

mindspore/nn/probability/bijector/scalar_affine.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Scalar Affine Bijector"""
-from mindspore.ops import operations as P
+import mindspore.ops as ops
 from ..distribution._utils.custom_ops import log_generic
 from .bijector import Bijector
 
@@ -86,10 +86,10 @@ class ScalarAffine(Bijector):
         self._scale = self._add_parameter(scale, 'scale')
         self._shift = self._add_parameter(shift, 'shift')
 
-        self.abs = P.Abs()
-        self.oneslike = P.OnesLike()
-        self.dtypeop = P.DType()
-        self.cast = P.Cast()
+        self.abs = ops.Abs()
+        self.oneslike = ops.OnesLike()
+        self.dtypeop = ops.DType()
+        self.cast = ops.Cast()
         self.log = log_generic
 
     @property

mindspore/nn/probability/bijector/softplus.py

@@ -14,8 +14,7 @@
 # ============================================================================
 """Softplus Bijector"""
 import numpy as np
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
+import mindspore.ops as ops
 from mindspore.nn.layer.activation import LogSigmoid
 from ..distribution._utils.custom_ops import exp_generic, log_generic
 from .bijector import Bijector
@@ -82,17 +81,17 @@ class Softplus(Bijector):
 
         self.exp = exp_generic
         self.log = log_generic
-        self.expm1 = P.Expm1()
-        self.abs = P.Abs()
-        self.dtypeop = P.DType()
-        self.cast = P.Cast()
-        self.greater = P.Greater()
-        self.less = P.Less()
+        self.expm1 = ops.Expm1()
+        self.abs = ops.Abs()
+        self.dtypeop = ops.DType()
+        self.cast = ops.Cast()
+        self.greater = ops.Greater()
+        self.less = ops.Less()
         self.log_sigmoid = LogSigmoid()
-        self.logicalor = P.LogicalOr()
-        self.select = P.Select()
-        self.shape = P.Shape()
-        self.sigmoid = P.Sigmoid()
+        self.logicalor = ops.LogicalOr()
+        self.select = ops.Select()
+        self.shape = ops.Shape()
+        self.sigmoid = ops.Sigmoid()
         self.softplus = self._softplus
         self.inverse_softplus = self._inverse_softplus
 
@@ -104,7 +103,7 @@ class Softplus(Bijector):
         too_large = self.greater(x, -self.threshold)
         too_small_value = self.exp(x)
         too_large_value = x
-        ones = F.fill(self.dtypeop(x), self.shape(x), 1.0)
+        ones = ops.fill(self.dtypeop(x), self.shape(x), 1.0)
         too_small_or_too_large = self.logicalor(too_small, too_large)
         x = self.select(too_small_or_too_large, ones, x)
         y = self.log(self.exp(x) + 1.0)
@@ -120,7 +119,7 @@ class Softplus(Bijector):
         too_large = self.greater(x, (-1) * self.threshold)
         too_small_value = self.log(x)
         too_large_value = x
-        ones = F.fill(self.dtypeop(x), self.shape(x), 1.0)
+        ones = ops.fill(self.dtypeop(x), self.shape(x), 1.0)
         too_small_or_too_large = self.logicalor(too_small, too_large)
         x = self.select(too_small_or_too_large, ones, x)
         y = x + self.log(self.abs(self.expm1((-1)*x)))

mindspore/nn/probability/distribution/_utils/utils.py

@@ -298,7 +298,7 @@ class CheckTuple(PrimitiveWithInfer):
         # The op is not used in a cell
         if isinstance(x, tuple):
             return x
-        if context.get_context("mode") == 0:
+        if context.get_context("mode") == context.GRAPH_MODE:
             return x["value"]
         raise TypeError(f"For {name}, input type must be a tuple.")
 
@@ -349,7 +349,7 @@ def set_param_type(args, hint_type):
     for name, arg in args.items():
         if hasattr(arg, 'dtype'):
             if isinstance(arg, np.ndarray):
-                cur_dtype = mstype.pytype_to_dtype(arg.dtype)
+                cur_dtype = mstype._pytype_to_dtype(arg.dtype)  # pylint:disable=protected-access
             else:
                 cur_dtype = arg.dtype
             if common_dtype is None:

mindspore/nn/wrap/cell_wrapper.py

@@ -23,7 +23,7 @@ from types import FunctionType, MethodType
 
 from mindspore import log as logger
 from mindspore.parallel._utils import _get_device_num, _get_gradients_mean,\
-    _get_parallel_mode, _get_enable_parallel_optimizer, _is_pynative_parallel
+    _get_parallel_mode, _get_enable_parallel_optimizer
 from mindspore.context import ParallelMode
 from mindspore import _checkparam as validator
 from mindspore import ops, nn
@@ -397,8 +397,7 @@ class TrainOneStepCell(Cell):
         self.reducer_flag = False
         self.grad_reducer = nn.Identity()
         self.parallel_mode = _get_parallel_mode()
-        self.reducer_flag = self.parallel_mode in (ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL) or \
-                            _is_pynative_parallel()
+        self.reducer_flag = self.parallel_mode in (ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL)
         if self.reducer_flag:
             self.mean = _get_gradients_mean()
             self.degree = _get_device_num()
@@ -860,7 +859,7 @@ class _BroadCastCell(Cell):
         from mindspore import context
         self.map_ = ops.Map()
         self.params = tuple(params)
-        if context.get_context("device_target") == "Ascend" and context.get_context("mode") != context.PYNATIVE_MODE:
+        if context.get_context("device_target") == "Ascend":
             rank_list = [id for id in range(0, get_group_size())]
             create_group("BroadcastWorldGroup", rank_list)
             self.broadcast = ops.Broadcast(0, group="BroadcastWorldGroup")
@@ -889,6 +888,8 @@ class PipelineCell(Cell):
         micro_size (int): MicroBatch size.
         stage_config (dict, optional): The stage configuration for each cell's execution in pipeline parallel.
             Default ``None``.
+        segment_config (dict, optional): The segment configuration for each cell's execution in pipeline parallel.
+            Default ``None``.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -900,7 +901,7 @@ class PipelineCell(Cell):
         >>> net = LeNet5()
         >>> net = nn.PipelineCell(net, 4)
     """
-    def __init__(self, network, micro_size, stage_config=None):
+    def __init__(self, network, micro_size, stage_config=None, segment_config=None):
         super(PipelineCell, self).__init__(auto_prefix=False)
         self.network = network
         self.micro_inputs = nn.CellList()
@@ -956,6 +957,39 @@ class PipelineCell(Cell):
                     print(cell_name)
                 raise KeyError("For 'PipelineCell', the argument 'stage_config' : {} is not "
                                "found in 'network' : {}".format(config_dict, network))
+        if segment_config is None:
+            return
+        self._config_segment(segment_config)
+
+
+    def _config_segment(self, segment_config=None):
+        """
+        Config segment num for cell.
+        """
+        config_dict = segment_config.copy()
+        for cell_name, cell in self.network.cells_and_names():
+            if cell_name in segment_config:
+                setattr(cell, "pipeline_segment", segment_config[cell_name])
+                del config_dict[cell_name]
+        if str(self.network) in segment_config:
+            setattr(self.network, "pipeline_segment", segment_config[str(self.network)])
+            del config_dict[str(self.network)]
+        # if there are any config elements left, print them
+        if config_dict:
+            for config_cell_name, config_segment_num in config_dict.items():
+                logger.error("pipeline_cell segment_config set pipeline_segment fail!")
+                logger.warning("config cell name:" + str(config_cell_name) +
+                               " config segment num:" + str(config_segment_num))
+            logger.warning("network:" + str(self.network))
+            logger.warning("cell name available:")
+            for cell_name, _ in self.network.cells_and_names():
+                logger.warning(cell_name)
+            raise KeyError("For 'PipelineCell', the argument 'segment_config' : {} is not "
+                           "found in 'network' : {}".format(config_dict, self.network))
+
+
+    def shard(self, in_strategy, out_strategy=None, parameter_plan=None, device="Ascend", level=0):
+        raise ValueError("For 'PipelineCell', no 'shard' on 'PipelineCell' is allowed.")
 
     def construct(self, *inputs):
         ret = None

mindspore/nn/wrap/grad_reducer.py

@@ -140,34 +140,6 @@ def _tensors_allreduce_post(degree, mean, allreduce_filter, grad):
     return grad
 
 
-@reduce_opt.register("Tensor", "Bool", "Function", "Function", "Bool", "Tensor", "Bool")
-def _tensors_allreduce_ps(degree, mean, allgather, allreduce, allreduce_filter, grad, ps_parameter):
-    """
-    Apply allreduce on gradient.
-
-    Args:
-        degree (int): The mean coefficient.
-        mean (bool): When mean is true, the mean coefficient (degree) would apply on gradients.
-        allgather (Primitive): The communication operator for sparse gradients.
-        allreduce (Primitive): The communication operator for gradients.
-        allreduce_filter (bool): When it is true, allreduce would apply.
-        grad (Tensor): The gradient tensor before operation.
-        ps_parameter (bool): Use parameter server or not.
-
-    Returns:
-        Tensor, the gradient tensor after operation.
-    """
-    if ps_parameter:
-        return grad
-
-    if allreduce_filter:
-        grad = allreduce(grad)
-        if mean:
-            grad = ops.tensor_mul(grad, ops.cast(degree, ops.dtype(grad)))
-        return grad
-    return grad
-
-
 @reduce_opt.register("Tensor", "Bool", "Function", "Function", "Bool", "RowTensor")
 def _tensors_allreduce_with_sparse(degree, mean, allgather, allreduce, allreduce_filter, grad):
     """
@@ -193,37 +165,6 @@ def _tensors_allreduce_with_sparse(degree, mean, allgather, allreduce, allreduce
         grad = RowTensorInner(indices, dout, grad.dense_shape)
     return grad
 
-
-@reduce_opt.register("Tensor", "Bool", "Function", "Function", "Bool", "RowTensor", "Bool")
-def _tensors_allreduce_with_sparse_ps(degree, mean, allgather, allreduce, allreduce_filter, grad, ps_parameter):
-    """
-    Apply allgather on gradient instead of allreduce for sparse feature.
-    Allgather is a communication operation used for distributed deep learning.
-
-    Args:
-        degree (int): The mean coefficient.
-        mean (bool): When mean is true, the mean coefficient (degree) would apply on gradients.
-        allgather (Primitive): The communication operator for sparse gradients.
-        allreduce (Primitive): The communication operator for gradients.
-        allreduce_filter (bool): When it is true, allgather would apply.
-        grad (tuple): The indices, gradient tensor and tensor_shape before operation.
-        ps_parameter (bool): Use parameter server or not.
-
-    Returns:
-        RowTensor, the gradient after operation.
-    """
-    if ps_parameter:
-        return grad
-
-    if allreduce_filter:
-        indices = allgather(grad.indices)
-        dout = allgather(grad.values)
-        if mean:
-            dout = ops.tensor_mul(dout, ops.cast(degree, ops.dtype(dout)))
-        grad = RowTensorInner(indices, dout, grad.dense_shape)
-    return grad
-
-
 _get_datatype = ops.MultitypeFuncGraph("_get_datatype")
 
 
@@ -394,7 +335,6 @@ class DistributedGradReducer(Cell):
 
     def __init__(self, parameters, mean=None, degree=None, fusion_type=1, group=GlobalComm.WORLD_COMM_GROUP):
         super(DistributedGradReducer, self).__init__(auto_prefix=False)
-        self._check_parallel_mode()
         self.map_ = ops.Map()
         self.mean = mean
         if mean is None:
@@ -424,9 +364,6 @@ class DistributedGradReducer(Cell):
                 self.split_fusion = False
                 self.allreduce = AllReduce('sum', group).add_prim_attr('fusion', fusion_type)
         self.allgather = AllGather(group)
-        ps_filter = lambda x: x.is_param_ps
-        self.ps_parameters = tuple(ps_filter(x) for x in parameters)
-        self.enable_parameter_server = any(self.ps_parameters)
         self.mode = context.get_context("mode")
         self.enable_tuple_broaden = True
 
@@ -447,29 +384,14 @@ class DistributedGradReducer(Cell):
         grads = self.map_(ops.partial(_cast_datatype, mstype.float32), grads)
 
         if self.split_fusion:
-            if self.enable_parameter_server:
-                new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather),
-                                     self.op_list, self.allreduce_filter, grads, self.ps_parameters)
-            else:
-                new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather),
-                                     self.op_list, self.allreduce_filter, grads)
+            new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather),
+                                 self.op_list, self.allreduce_filter, grads)
         else:
-            if self.enable_parameter_server:
-                new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather,
-                                                 self.allreduce), self.allreduce_filter, grads, self.ps_parameters)
-            else:
-                new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather,
-                                                 self.allreduce), self.allreduce_filter, grads)
+            new_grad = self.map_(ops.partial(reduce_opt, self.degree, self.mean, self.allgather,
+                                             self.allreduce), self.allreduce_filter, grads)
         new_grad = self.map_(ops.partial(_cast_datatype), datatypes, new_grad)
         return new_grad
 
-    def _check_parallel_mode(self):
-        """check parallel mode"""
-        parallel_mode = context.get_auto_parallel_context('parallel_mode')
-        if context.get_context('mode') == context.GRAPH_MODE and parallel_mode in (
-                context.ParallelMode.SEMI_AUTO_PARALLEL, context.ParallelMode.AUTO_PARALLEL):
-            raise RuntimeError("{} can not use DistributedGradReducer in graph mode".format(parallel_mode))
-
 
 grad_scale = ops.MultitypeFuncGraph("grad_scale")
 shard_grad_scale = ops.MultitypeFuncGraph("shard_grad_scale")
@@ -587,7 +509,6 @@ class PipelineGradReducer(Cell):
     """
     def __init__(self, parameters, scale_sense=1.0, opt_shard=None):
         super(PipelineGradReducer, self).__init__(auto_prefix=False)
-        self._check_mode()
         self.accu_grads = parameters.clone(prefix="accu_grads", init="zeros")
         self.grad_reducer = Identity()
         self.degree = Tensor(1, mstype.float32)
@@ -609,9 +530,3 @@ class PipelineGradReducer(Cell):
             accu_grads = self.grad_reducer(self.accu_grads)
             new_grads = self.hyper_map(ops.partial(grad_scale, self.scale_sense * self.degree), grads, accu_grads)
         return new_grads
-
-    def _check_mode(self):
-        """check parallel mode"""
-        mode = context.get_context('mode')
-        if mode != context.GRAPH_MODE:
-            raise RuntimeError(f"PipelineGradReducer only support graph mode, but get {mode}")

mindspore/numpy/array_creations.py

@@ -127,7 +127,7 @@ def asarray_const(a, dtype=None):
         # If dtype is not specified, we keep consistent with numpy decision
         # only exceptions are: we use int/float32
         if dtype is None:
-            dtype = mstype.pytype_to_dtype(a.dtype)
+            dtype = mstype._pytype_to_dtype(a.dtype)  # pylint:disable=protected-access
             if dtype == mstype.float64:
                 dtype = mstype.float32
             elif dtype == mstype.int64:
@@ -138,7 +138,7 @@ def asarray_const(a, dtype=None):
     if isinstance(a, onp.ndarray) and dtype is None:
         if a.dtype is onp.dtype('object'):
             raise TypeError(f"For Tensor conversion, the input_data is {a} that contains unsupported element.")
-        dtype = mstype.pytype_to_dtype(a.dtype)
+        dtype = mstype._pytype_to_dtype(a.dtype)  # pylint:disable=protected-access
         a = Tensor.from_numpy(a)
 
     return Tensor(a, dtype=dtype)
@@ -2622,7 +2622,7 @@ def pad(arr, pad_width, mode="constant", stat_length=None, constant_values=0,
             unique pad widths for each axis. ``((before, after),)`` yields same
             before and after pad for each axis. ``(pad,)`` or int is a shortcut
             for ``before = after = pad width`` for all axes.
-        mode (string, optional):
+        mode (str, optional):
             One of the following string values:
 
             - constant (default): Pads with a constant value.
@@ -2660,7 +2660,7 @@ def pad(arr, pad_width, mode="constant", stat_length=None, constant_values=0,
             unique end values for each axis. ``((before, after),)`` yields same before
             and after end values for each axis. ``(constant,)`` or ``constant``
             is a shortcut for ``before = after = constant`` for all axes. Default: ``0`` .
-        reflect_type(string, optional) can choose between \'even\' and \'odd\'. Used in
+        reflect_type(str, optional) can choose between \'even\' and \'odd\'. Used in
             \'reflect\', and \'symmetric\'. The \'even\' style is the default with an
             unaltered reflection around the edge value. For the \'odd\' style, the extended
             part of the `arr` is created by subtracting the reflected values from two times

mindspore/numpy/fft.py

@@ -185,7 +185,7 @@ def rfft(a, n=None, axis=-1, norm=None):
             Default: ``None``.
         axis (int, optional): Axis over which to compute the `rfft`.
             Default: ``-1``, which means the last axis of `a` is used.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"``.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"``.
             Three modes are defined as,
 
             - ``"backward"`` (no normalization).
@@ -224,7 +224,7 @@ def irfft(a, n=None, axis=-1, norm=None):
             Default: ``None``.
         axis (int, optional): Axis over which to compute the `irfft`.
             Default: ``-1``, which means the last axis of `a` is used.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"``.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"``.
             Three modes are defined as,
 
             - ``"backward"`` (normalize by :math:`1/n`).
@@ -266,7 +266,7 @@ def fft2(a, s=None, axes=(-2, -1), norm=None):
             Default: ``None`` , which does not need to process `a`.
         axes (tuple[int], optional): The dimension along which to take the one dimensional `fft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
@@ -361,7 +361,7 @@ def fftn(a, s=None, axes=None, norm=None):
         axes (tuple[int], optional): The dimension along which to take the one dimensional `fftn`.
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
@@ -409,7 +409,7 @@ def ifftn(a, s=None, axes=None, norm=None):
         axes (tuple[int], optional): The dimension along which to take the one dimensional `ifftn`.
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (normalize by :math:`1/n`).
@@ -457,7 +457,7 @@ def rfft2(a, s=None, axes=(-2, -1), norm=None):
             Default: ``None`` , which does not need to process `a`.
         axes (tuple[int], optional): The dimension along which to take the one dimensional `rfft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
@@ -502,7 +502,7 @@ def irfft2(a, s=None, axes=(-2, -1), norm=None):
             Default: ``None`` , the axes[-1] of the `a` will be zero-padded to :math:`2*(a.shape[axes[-1]]-1)`.
         axes (tuple[int], optional): The dimension along which to take the one dimensional `irfft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `a`.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (normalize by :math:`1/n`).
@@ -551,7 +551,7 @@ def rfftn(a, s=None, axes=None, norm=None):
         axes (tuple[int], optional): The dimension along which to take the one dimensional `rfftn`.
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
@@ -599,7 +599,7 @@ def irfftn(a, s=None, axes=None, norm=None):
         axes (tuple[int], optional): The dimension along which to take the one dimensional `irfftn`.
             Default: ``None`` , which means transform the all dimension of `a`,
             or the last `len(s)` dimensions if s is given.
-        norm (string, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (normalize by :math:`1/n`).

mindspore/numpy/utils_const.py

@@ -70,7 +70,7 @@ def _check_dtype(dtype):
         elif dtype is float:
             dtype = mstype.float32
         else:
-            dtype = mstype.pytype_to_dtype(dtype)
+            dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
     if dtype not in dtype_tuple:
         raise TypeError(f"only {all_types} are allowed for dtype, but got {type(dtype)}")
     return dtype

mindspore/{nn/reinforcement → onnx}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2025 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,13 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""
-TensorArray.
-"""
+"""onnx module."""
+
 from __future__ import absolute_import
 
-from mindspore.nn.reinforcement.tensor_array import TensorArray
+from .onnx_export import export
 
-__all__ = [
-    "TensorArray",
-]
+__all__ = ["export"]