mindspore 2.4.10__cp39-none-any.whl → 2.5.0__cp39-none-any.whl

mindspore/_extends/parse/standard_method.py

@@ -17,16 +17,19 @@
 """standard_method"""
 
 from __future__ import absolute_import
-from mindspore import Tensor, CSRTensor, COOTensor
+from mindspore import Tensor, CSRTensor, COOTensor, Parameter
 from mindspore import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore.common import mutable
+from mindspore.common.generator import default_generator
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 from mindspore.ops.operations._sequence_ops import TensorToTuple
-from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op
+from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op, inplace_index_put_op, inplace_normal_op, inplace_index_add_op
+from mindspore.ops.auto_generate import inplace_copy_op
+from mindspore.ops.auto_generate import inplace_scatter_add as inplace_scatter_add_
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -39,7 +42,6 @@ from ...ops.composite import MultitypeFuncGraph, env_get, hyper_add, \
     zeros_like, ones_like, repeat_elements, multitype_ops
 from ...ops.composite.multitype_ops import _constexpr_utils as const_utils
 from ...ops.composite.multitype_ops import _compile_utils as compile_utils
-from ...ops.operations.math_ops import Median
 from ...ops.operations._inner_ops import Format
 from ...ops.operations import _csr_ops
 from ...ops.operations import _map_tensor_ops
@@ -66,11 +68,13 @@ _csr_mm = _csr_ops.CSRMM()
 itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
                 mstype.float16: 2, mstype.int16: 2, mstype.uint16: 2,
                 mstype.float32: 4, mstype.int32: 4, mstype.uint32: 4,
-                mstype.float64: 8, mstype.int64: 8, mstype.uint64: 8}
+                mstype.float64: 8, mstype.int64: 8, mstype.uint64: 8,
+                mstype.bfloat16: 2}
 
 nan_tensor = Tensor(float('nan'), dtype=mstype.float32)
 
 _map = composite.HyperMap()
+generator_step_ = Tensor(12, mstype.int64)
 
 
 def hypermap_dynamic_tuple(func, *inputs):
@@ -103,6 +107,14 @@ def hypermap_dynamic_list(func, *inputs):
     return ret
 
 
+def index_add_(x, dim, index, source, *, alpha=1):
+    """
+    Accumulate the elements of `alpha` times `source` into the `self` by adding to the indices
+    in the order given in `index`.
+    """
+    return inplace_index_add_op(x, dim, index, source, alpha)
+
+
 def mean(x, axis=None, keep_dims=False):
     """
     Reduces a dimension of a tensor by averaging all elements in the dimension.
@@ -945,17 +957,11 @@ def argmin_with_value(x, axis=0, keep_dims=False):
     return F.min(x, axis, keep_dims)
 
 
-def median(input, global_median, axis=0, keep_dims=False):
+def median(input, axis=-1, keepdims=False):
     r"""
     Computes the median of input tensor.
-
-    .. warning::
-        When attr `global_median` is True, the second output Tensor value is meaningless.
-
     """
-    check_axis_in_range(axis, input.ndim)
-    median_ = Median(global_median, axis, keep_dims)
-    return median_(input)
+    return F.median(input, axis, keepdims)
 
 
 def msort(x):
@@ -1102,6 +1108,13 @@ def copy(x):
     return x
 
 
+def copy_(self, src, non_blocking=False):
+    """
+    Copies the elements from src into self tensor and returns self.
+    """
+    return inplace_copy_op(self, src)
+
+
 def max(input, axis=None, keepdims=False, *, initial=None,  # pylint: disable=redefined-builtin
         where=True, return_indices=False):  # pylint: disable=redefined-outer-name
     """
@@ -1476,7 +1489,7 @@ def lgamma(input):
 
 def i0(x):
     """
-    For details, please refer to :func:`mindspore.ops.i0`.
+    For details, please refer to :func:`mindspore.ops.bessel_i0`.
     """
     return F.i0(x)
 
@@ -1931,6 +1944,13 @@ def clamp(x, min=None, max=None):
     return F.clamp(x, min, max)
 
 
+def clamp_(x, min=None, max=None):
+    """
+    Clamps all elements in `x` into the range `[min, max]`.
+    """
+    return F.clamp_(x, min, max)
+
+
 def clip(x, min=None, max=None):
     """
     Clamps all elements in `x` into the range `[min, max]`.
@@ -2312,9 +2332,9 @@ def setitem(data, index, value):
     return data.__setitem__(index, value)
 
 
-def item(data, *args):
+def item(data):
     """Implementation of `item`."""
-    return compile_utils.tensor_item(data, *args)
+    return compile_utils.tensor_item(data)
 
 
 def itemset(data, *args):
@@ -2773,9 +2793,9 @@ def enumerate_(x, start=0):
     return ret
 
 
-def expand_tensor_as(x, y):
+def expand_tensor_as(input, x):
     """Expand tensor"""
-    return F.broadcast_to(x, shape_(y))
+    return F.broadcast_to(input, shape_(x))
 
 
 def broadcast_to(x, shape):
@@ -2815,8 +2835,8 @@ def col2im(*inputs):
 
 def narrow(input, axis, start, length):
     """
-    Returns a narrowed tensor from input tensor.
-    The dimension axis is input from start to start + length.
+    Obtains a tensor of a specified length at a
+    specified start position along a specified axis.
     """
     return F.narrow(input, axis, start, length)
 
@@ -2980,6 +3000,11 @@ def tanh(x):
     return F.tanh(x)
 
 
+def tanh_(x):
+    """Returns hyperbolic tangent of `x`."""
+    return F.tanh_(x)
+
+
 def cosh(x):
     """
     Computes hyperbolic cosine of `x` element-wise.
@@ -3011,6 +3036,13 @@ def tensor_scatter_add(x, indices, updates):
     return F.tensor_scatter_add(x, indices, updates)
 
 
+def inplace_scatter_add(input, dim, index, src):
+    """
+    Add all elements in `src` to the index specified by `index` to `self` along dimension specified by `dim`.
+    """
+    return inplace_scatter_add_(input, dim, index, src)
+
+
 def tensor_scatter_sub(x, indices, updates):
     """
     Creates a new tensor by subtracting the values from the positions in `x` indicated by
@@ -3076,11 +3108,11 @@ def negative(input):
     return F.neg(input)
 
 
-def nonzero(input, as_tuple=False):
+def nonzero(input, *, as_tuple=False):
     """
     Return a Tensor of the positions of all non-zero values.
     """
-    return F.nonzero(input, as_tuple)
+    return F.nonzero(input, as_tuple=as_tuple)
 
 
 def new_zeros(x, size, *, dtype=None):
@@ -3370,6 +3402,23 @@ def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
     return F.norm(A, ord, dim, keepdim, dtype=dtype)
 
 
+def normal_(input, mean=0, std=1, *, generator=None):
+    """
+    Update the `input` tensor in place by generating random numbers sampled from the normal
+    distribution which constructed by the parameters `mean` and `std`.
+
+    For details, please refer to :func:`mindspore.Tensor.normal_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(  # pylint: disable=protected-access
+        generator_step_)
+    return inplace_normal_op(input, mean, std, seed, offset)
+
+
 def renorm(input_x, p, dim, maxnorm):
     """
     Renormalizes the sub-tensors along dimension `dim`, and each sub-tensor's p-norm should not exceed the
@@ -3911,42 +3960,62 @@ def to(input_x, dtype):
     r"""
     Performs tensor dtype conversion.
     """
-    return P.Cast()(input_x, dtype)
+    return F.cast(input_x, dtype)
 
 
 def to_bool(input_x):
     r"""
     Converts input tensor dtype to bool.
     """
-    return P.Cast()(input_x, mstype.bool_)
+    return F.cast(input_x, mstype.bool_)
 
 
 def to_float(input_x):
     r"""
     Converts input tensor dtype to float32.
     """
-    return P.Cast()(input_x, mstype.float32)
+    return F.cast(input_x, mstype.float32)
 
 
 def to_half(input_x):
     r"""
     Converts input tensor dtype to float16.
     """
-    return P.Cast()(input_x, mstype.float16)
+    return F.cast(input_x, mstype.float16)
 
 
 def to_int(input_x):
     r"""
     Converts input tensor dtype to int32.
     """
-    return P.Cast()(input_x, mstype.int32)
+    return F.cast(input_x, mstype.int32)
 
 
 def to_long(input_x):
     r"""
     Converts input tensor dtype to int64.
     """
-    return P.Cast()(input_x, mstype.int64)
+    return F.cast(input_x, mstype.int64)
+
+
+def to_double(input_x):
+    r"""
+    Converts input tensor dtype to float64.
+    """
+    return F.cast(input_x, mstype.float64)
+
+def to_bfloat16(input_x):
+    r"""
+    Converts input tensor dtype to bfloat16.
+    """
+    return F.cast(input_x, mstype.bfloat16)
+
+
+def to_byte(input_x):
+    r"""
+    Converts input tensor dtype to uint8.
+    """
+    return F.cast(input_x, mstype.uint8)
 
 
 def cholesky(input_x, upper=False):
@@ -4428,6 +4497,16 @@ def index_put(input, indices, values, accumulate=False):
     return _index_put(input, values, indices)
 
 
+def index_put_(input, indices, values, accumulate=False):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.index_put_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    return inplace_index_put_op(input, indices, values, accumulate)
+
+
 def aminmax(input, *, axis=0, keepdims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.aminmax`.
@@ -4462,14 +4541,31 @@ def outer(input, vec2):
     """
     return F.outer(input, vec2)
 
+
 def sigmoid(input):
     r"""
     For details, please refer to :func:`mindspore.ops.sigmoid`.
     """
     return F.sigmoid(input)
 
+
 def _getitem(data, index):
     return multitype_ops.getitem(data, index)
 
+
 def _setitem(data, index, value):
     return multitype_ops.setitem(data, index, value)
+
+
+def register_hook(x, func):
+    if isinstance(x, Parameter):
+        raise ValueError("Register hook for Parameter inside graph is not supported.")
+    hook_op = P.InsertGradientOf(func)
+    return hook_op(x)
+
+
+def zero_(input):
+    r"""
+    Return a tensor filled with zeros.
+    """
+    return F.zero_(input)

mindspore/_extends/pijit/pijit_func_white_list.py

@@ -127,7 +127,7 @@ from mindspore.dataset.vision.transforms import AdjustBrightness, AdjustContrast
     RandomVerticalFlipWithBBox as VRandomVerticalFlipWithBBox, Rescale as VRescale, Resize as VResize, ResizedCrop, \
     ResizeWithBBox as VResizeWithBBox, Rotate as VRotate, SlicePatches as VSlicePatches, Solarize, ToTensor,\
     TrivialAugmentWide, UniformAugment as VUniformAugment, VerticalFlip as VVerticalFlip
-from mindspore.profiler.profiling import Profiler
+from mindspore.profiler.profiler import Profiler
 from mindspore.communication._hccl_management import get_rank_size, get_rank_id
 from mindspore.communication._comm_helper import _create_group_helper, _destroy_group_helper
 from mindspore.communication.management import _set_rank_from_mpi, init as cinit, release as crelease

mindspore/amp.py

@@ -69,6 +69,12 @@ def _enable_all_finite():
         if not checker.check_custom_version():
             logger.debug("Disable AllFinite due to version check failure.")
             return False
+    else:
+        return False
+
+    if "RANK_TABLE_FILE" in os.environ:
+        return False
+
     runtime_conf = os.environ.get('MS_DEV_RUNTIME_CONF')
     global_jit_config = context.get_jit_config()
     if runtime_conf is not None and ("all_finite:True" in runtime_conf or "all_finite:true" in runtime_conf):
@@ -82,7 +88,7 @@ def _enable_all_finite():
     if global_jit_config:
         logger.debug("Current global jit config is: {}".format(global_jit_config["jit_level"]))
         return global_jit_config["jit_level"] == "O0" or global_jit_config["jit_level"] == "O1"
-    return False
+    return True
 
 
 def _grad_unscale(scale, grad):

mindspore/boost/boost_cell_wrapper.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-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.
@@ -15,6 +15,7 @@
 """Boost Mode Cell Wrapper."""
 from __future__ import absolute_import
 
+import os
 import numpy as np
 from mindspore.nn.wrap import TrainOneStepCell
 import mindspore.context as context
@@ -38,6 +39,10 @@ from mindspore.boost.adasum import AdaSum
 from mindspore.boost.dim_reduce import DimReduce
 from mindspore.boost.grad_accumulation import gradient_accumulation_op, gradient_clear_op
 from mindspore.boost.base import _load_local_pca_mat
+from mindspore.ops.operations.nn_ops import AllFinite
+from mindspore._c_expression import MSContext
+from mindspore.run_check._check_version import AscendEnvChecker
+from mindspore import log as logger
 
 __all__ = ["BoostTrainOneStepCell", "BoostTrainOneStepWithLossScaleCell"]
 
@@ -90,6 +95,27 @@ def _tensor_grad_overflow(grad):
 def _tensor_grad_overflow_row_tensor(grad):
     return grad_overflow(grad.values)
 
+_ascend_grad_overflow = C.MultitypeFuncGraph("_ascend_grad_overflow")
+ascend_grad_overflow = P.IsFinite()
+
+
+@_ascend_grad_overflow.register("Tensor")
+def _tensor_ascend_grad_overflow(grad):
+    status = ascend_grad_overflow(grad)
+    base = Tensor(1.0, dtype=mstype.float32)
+    output = base - status.all()
+    output = P.Reshape()(output, ((-1,)))
+    return output
+
+
+@_ascend_grad_overflow.register("RowTensor")
+def _tensor_ascend_grad_overflow_row_tensor(grad):
+    status = ascend_grad_overflow(grad.values)
+    base = Tensor(1.0, dtype=mstype.float32)
+    output = base - status.all()
+    output = P.Reshape()(output, ((1,)))
+    return output
+
 
 class _OutputToFloat16(Cell):
     "Wrap cell for amp. Cast network output back to float16"
@@ -483,7 +509,11 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
         self.allreduce = P.AllReduce()
         self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
         self.gpu_target = (context.get_context("device_target") == "GPU")
+        self.ascend_910a_target = (MSContext.get_instance().get_ascend_soc_version() == 'ascend910')
+        self.ascend_910b_target = (MSContext.get_instance().get_ascend_soc_version() in ['ascend910b', 'ascend910_93'])
         self.loss_scaling_manager = None
+        self._ascend_check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
+
         self.base0 = Tensor(0, mstype.int32)
         self.reduce_all = P.ReduceAll(keep_dims=False)
         self.logic_not = P.LogicalNot()
@@ -512,6 +542,26 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
             else:
                 raise TypeError("The scale_sense must be Cell or Tensor, but got {}".format(type(scale_sense)))
 
+        self.enable_allfinite = True
+        runtime_conf = os.environ.get('MS_DEV_RUNTIME_CONF')
+        global_jit_config = context.get_jit_config()
+        if runtime_conf is not None and ("all_finite:True" in runtime_conf or "all_finite:true" in runtime_conf):
+            logger.debug("Enable AllFinite through the environment variable MS_DEV_RUNTIME_CONF.")
+            self.enable_allfinite = True
+        elif runtime_conf is not None and ("all_finite:False" in runtime_conf or "all_finite:false" in runtime_conf):
+            logger.debug("Disable AllFinite through the environment variable MS_DEV_RUNTIME_CONF.")
+            self.enable_allfinite = False
+        elif global_jit_config:
+            logger.debug("Current global jit config is: {}".format(global_jit_config["jit_level"]))
+            self.enable_allfinite = global_jit_config["jit_level"] == "O0" or global_jit_config["jit_level"] == "O1"
+        if "RANK_TABLE_FILE" in os.environ:
+            self.enable_allfinite = False
+        if self.ascend_910b_target:
+            checker = AscendEnvChecker(None)
+            if not checker.check_custom_version():
+                logger.debug("Disable AllFinite due to version check failure.")
+                self.enable_allfinite = False
+
     def construct(self, *inputs):
         weights = self.weights
         loss = self.network(*inputs)
@@ -523,7 +573,7 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
             cond, scaling_sens = self._enhanced_amp_process_overflow_status(grads)
         else:
             scaling_sens = self.scale_sense
-            status, scaling_sens = self._start_overflow_check(loss, scaling_sens)
+            status = Tensor([0] * 8, mstype.int32)
             scaling_sens_filled = C.ones_like(loss) * F.cast(scaling_sens, F.dtype(loss))
 
             grads = self.grad(self.network, weights)(*inputs, scaling_sens_filled)
@@ -646,54 +696,99 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
             compute_input = F.depend(compute_input, clear_status)
         return status, compute_input
 
+    def _check_overflow_status_on_infnan_mode(self, grad_overflow_check_func, compute_output):
+        """check overflow status on infnan mode."""
+        flag_sum = self.hyper_map(F.partial(grad_overflow_check_func), compute_output)
+        flag_sum = P.AddN()(flag_sum)
+        # convert flag_sum to scalar
+        flag_sum = P.Reshape()(flag_sum, (()))
+        return flag_sum
+
+    def _get_distributed_overflow_status_on_infnan_mode(self, grad_overflow_check_func, compute_output):
+        """converge the distributed overflow status on infnan mode."""
+        flag_sum = self._check_overflow_status_on_infnan_mode(grad_overflow_check_func, compute_output)
+
+        if self.is_distributed:
+            # sum overflow flag over devices
+            flag_reduce = self.allreduce(flag_sum)
+            overflow = self.less_equal(self.base, flag_reduce)
+        else:
+            overflow = self.less_equal(self.base, flag_sum)
+        return overflow
+
+    def _get_distributed_overflow_status_on_infnan_enable_allfinite(self, compute_output):
+        """check overflow status on infnan kernel mode."""
+        overflow = AllFinite()(compute_output)
+
+        if self.is_distributed:
+            overflow = P.Cast()(overflow, mstype.int8)
+            overflow = P.Cast()(self.allreduce(overflow), mstype.bool_)
+        return overflow
+
+    def _get_gpu_overflow_status(self, compute_output):
+        """get overflow status of gpu."""
+        overflow = self._get_distributed_overflow_status_on_infnan_mode(_grad_overflow, compute_output)
+        return overflow
+
+    def _get_ascend_overflow_status_on_infnan_mode(self, compute_output):
+        """get overflow status of ascend on infnan mode."""
+        overflow = False
+        if self.enable_allfinite:
+            overflow = self._get_distributed_overflow_status_on_infnan_enable_allfinite(compute_output)
+        else:
+            overflow = self._get_distributed_overflow_status_on_infnan_mode(_ascend_grad_overflow, compute_output)
+        return overflow
+
+    def _get_ascend_overflow_status_on_saturation_mode(self, status, compute_output):
+        """get overflow status of ascend on saturation mode"""
+        status = F.depend(status, compute_output)
+        get_status = NPUGetFloatStatusV2()(status)
+
+        if self.is_distributed:
+            # sum overflow flag over devices
+            flag_reduce = self.allreduce(get_status)
+            # get_status not equal to [0]*8 means overflow
+            flag = self.equal(self.base0, flag_reduce)
+            status = F.depend(status, flag)
+            # distributed needs to skip allreduce to avoid its overflow affecting the next step
+            clear_status = NPUClearFloatStatusV2()(status)
+            flag = F.depend(flag, clear_status)
+            overall_finite = self.reduce_all(flag)
+        else:
+            status = F.depend(status, get_status)
+            clear_status = NPUClearFloatStatusV2()(status)
+            get_status = F.depend(get_status, clear_status)
+            flag = self.equal(self.base0, get_status)
+            overall_finite = self.reduce_all(flag)
+        overflow = self.logic_not(overall_finite)
+        return overflow
+
+
     def _get_overflow_status(self, status, compute_output):
         """
         Get floating-point overflow status.
 
-        Get overflow results after executing the target process for overflow detection.
+        Get overflow results after executing the target process for overflow detection. User-defined training network
+        based on this class can also call this interface to process the overflow.
 
-        Inputs:
-            - **status** (object) - A status instance used to detect the overflow.
-            - **compute_output** - Overflow detection should be performed on a certain computation. Set `compute_output`
-              as the output of the computation, to ensure overflow status is acquired before executing the
-              computation.
+        Args:
+            status (object): To control the execution sequence with start_overflow_check, it should be set as the first
+              output of start_overflow_check.
+            compute_output: Overflow detection should be performed in a certain computation process. Set
+              `compute_output` as the output of the computation process.
 
-        Outputs:
+        Returns:
             bool, whether the overflow occurs or not.
         """
-        if not self.gpu_target:
-            status = F.depend(status, compute_output)
-            get_status = NPUGetFloatStatusV2()(status)
-
-            if self.is_distributed:
-                # sum overflow flag over devices
-                flag_reduce = self.allreduce(get_status)
-                # get_status not equal to [0]*8 means overflow
-                flag = self.equal(self.base0, flag_reduce)
-                status = F.depend(status, flag)
-                # distributed needs to skip allreduce to avoid its overflow affecting the next step
-                clear_status = NPUClearFloatStatusV2()(status)
-                flag = F.depend(flag, clear_status)
-                overall_finite = self.reduce_all(flag)
-            else:
-                status = F.depend(status, get_status)
-                clear_status = NPUClearFloatStatusV2()(status)
-                get_status = F.depend(get_status, clear_status)
-                flag = self.equal(self.base0, get_status)
-                overall_finite = self.reduce_all(flag)
-            overflow = self.logic_not(overall_finite)
-        else:
-            flag_sum = self.hyper_map(F.partial(_grad_overflow), compute_output)
-            flag_sum = P.AddN()(flag_sum)
-            # convert flag_sum to scalar
-            flag_sum = P.Reshape()(flag_sum, (()))
-
-            if self.is_distributed:
-                # sum overflow flag over devices
-                flag_reduce = self.allreduce(flag_sum)
-                overflow = self.less_equal(self.base, flag_reduce)
+        if self.gpu_target:
+            overflow = self._get_gpu_overflow_status(compute_output)
+        elif self.ascend_910b_target:
+            if self._ascend_check_overflow_mode == "SATURATION_MODE":
+                overflow = self._get_ascend_overflow_status_on_saturation_mode(status, compute_output)
             else:
-                overflow = self.less_equal(self.base, flag_sum)
+                overflow = self._get_ascend_overflow_status_on_infnan_mode(compute_output)
+        else:  # ascend_910a_target
+            overflow = self._get_ascend_overflow_status_on_saturation_mode(status, compute_output)
         return overflow
 
     def _process_loss_scale(self, overflow):

mindspore/common/__init__.py

@@ -15,7 +15,8 @@
 """Top-level reference to dtype of common module."""
 from __future__ import absolute_import
 from mindspore.common import dtype
-from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad, flops_collection
+from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad, \
+    flops_collection, set_recursion_limit
 from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc, int64, intp, \
     uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
     float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
@@ -75,6 +76,7 @@ __all__.extend([
     "set_seed", "get_seed", "manual_seed", # random seed
     "set_dump",
     "ms_memory_recycle",
+    "set_recursion_limit",
     "mutable", "JitConfig",
     "flops_collection",
     "lazy_inline", "load_mindir", "save_mindir",

mindspore/common/_register_for_tensor.py

@@ -43,4 +43,3 @@ class Registry:
 
 
 tensor_operator_registry = Registry()
-tensor_operator_registry_for_mint = Registry()