mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/common/dtype.py

@@ -23,6 +23,7 @@ import numpy as np
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
 from mindspore._c_expression.np_dtypes import np_version_valid
+
 if np_version_valid(False):
     from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
@@ -46,7 +47,9 @@ __dtype__ = [
     "TensorType", "_null",
     "Type", "Int",
     "complex64", "complex128",
-    "bfloat16", "qint4x2"
+    "bfloat16", "qint4x2",
+    "float8_e4m3fn", "float8_e5m2",
+    "hifloat8"
 ]
 
 __method__ = [
@@ -86,6 +89,9 @@ float32 = typing.kFloat32
 single = float32
 float64 = typing.kFloat64
 double = float64
+float8_e4m3fn = typing.kFloat8E4M3FN
+float8_e5m2 = typing.kFloat8E5M2
+hifloat8 = typing.kHiFloat8
 bfloat16 = typing.kBFloat16
 complex64 = typing.kComplex64
 complex128 = typing.kComplex128
@@ -145,17 +151,19 @@ number_type = (int8,
                bfloat16,
                complex64,
                complex128,
-               qint4x2,)
+               qint4x2,
+               float8_e4m3fn,
+               float8_e5m2,
+               hifloat8)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64, bfloat16,)
-signed_type = (int8, byte, int16, short, int32, intc, int64,
-               intp, float16, half, float32, single, float64,
-               double, bfloat16, complex64, complex128)
+float_type = (float16, float32, float64, bfloat16, float8_e4m3fn, float8_e5m2, hifloat8)
+signed_type = (int8, byte, int16, short, int32, intc, int64, intp, float16, half, float32, single, float64, double,
+               bfloat16, complex64, complex128, float8_e4m3fn, float8_e5m2, hifloat8)
 complex_type = (complex64, complex128,)
-all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128)
-implicit_conversion_seq = {t: idx for idx, t in enumerate(all_types)}
+all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128,
+             float8_e4m3fn, float8_e5m2, hifloat8)
 
 _simple_types = {
     list: list_,
@@ -281,8 +289,11 @@ def dtype_to_nptype(type_):
     }
     if type_ == bfloat16:
         if not np_version_valid(True):
-            raise TypeError("The Numpy bfloat16 data type is not supported now, please ensure that the current "
-                            "Numpy version is not less than the version when the mindspore is compiled.")
+            raise TypeError(
+                "The Numpy bfloat16 data type is not supported now, please ensure that the current "
+                "Numpy version is not less than the version when the mindspore is compiled, "
+                "and the major versions are same."
+            )
         return np_bfloat16
     return _dtype_nptype_dict[type_]
 
@@ -335,7 +346,6 @@ def _issubclass_(type_, dtype):
     return typing.is_subclass(type_, dtype)
 
 
-
 def type_size_in_bytes(dtype):
     """
     Return type size in bytes.

mindspore/common/dump.py

@@ -25,15 +25,19 @@ def set_dump(target, enabled=True):
     Enable or disable dump for the `target` and its contents.
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when Synchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document
-    <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
+    Please note that this API takes effect only when the Dump function is enabled, and the `dump_mode`
+    field in the Dump configuration file is set to `"2"` with the `ms_backend` compilation backend
+    (please refer to the backend parameter in
+    `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_).
+    See the `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
     The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
     Note:
-        1. This API is only effective for GRAPH_MODE whose graph compilation level is O0/O1 with Ascend backend,
-           and can not work for fusion Primitive operators.
+        1. This API is only available for JIT compilation, requires 'Ascend' as the device_target and
+           `ms_backend` as the compilation backend (please refer to the backend parameter in
+           `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_),
+           and does not support fused operators.
         2. This API only supports being called before training starts.
            If you call this API during training, it may not be effective.
         3. After using `set_dump(Cell, True)` , operators in forward and backward
@@ -66,7 +70,6 @@ def set_dump(target, enabled=True):
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, set_dump
         >>>
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> ms.set_device(device_target="Ascend")
         >>>
         >>> class MyNet(nn.Cell):
@@ -75,6 +78,7 @@ def set_dump(target, enabled=True):
         ...         self.conv1 = nn.Conv2d(5, 6, 5, pad_mode='valid')
         ...         self.relu1 = nn.ReLU()
         ...
+        ...     @jit
         ...     def construct(self, x):
         ...         x = self.conv1(x)
         ...         x = self.relu1(x)
@@ -109,15 +113,6 @@ def set_dump(target, enabled=True):
              "If you have Ascend device, consider set device_target to Ascend "
              "before calling set_dump.".format(current_target))
 
-    current_mode = context.get_context("mode")
-    if current_mode != context.GRAPH_MODE:
-        # We will not return here in case user changed mode later.
-        warn(
-            "Current mode is PYNATIVE_MODE, which is not supported by set_dump. "
-            "Only GRAPH_MODE is supported currently. "
-            "Consider set mode to GRAPH_MODE "
-            "before calling set_dump.")
-
     # The actual set dump logic.
     if isinstance(target, nn.Cell):
         target.add_flags(dump=enabled)

mindspore/common/generator.py

@@ -56,6 +56,9 @@ class Generator:
     A generator that manages the state of random numbers and provides seed and offset for random functions.
     When the seed and offset are fixed, the random function generates the same random sequence.
 
+    .. note::
+        Graph mode does not support the use of multiple generators at the same time for now.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -74,10 +77,9 @@ class Generator:
     """
 
     def __init__(self):
-        self._seed = Parameter(Tensor(0, mstype.int64),
-                               name="seed", requires_grad=False)
+        self._seed = Parameter(Tensor(0, mstype.int64), requires_grad=False)
         self._offset = Parameter(
-            Tensor(0, mstype.int64), name="offset", requires_grad=False)
+            Tensor(0, mstype.int64), requires_grad=False)
 
         self._generator = GeneratorOp().set_device("CPU")
         self._generator.add_prim_attr("manual_seed", False)

mindspore/common/hook_handle.py

@@ -81,19 +81,23 @@ class HookHandle:
         It is only supported in pynative mode and works when registering or removing hook function for Cell object.
 
     Args:
-        hook_dict (Dict): The hook object with hook function registered on. Default value: None.
+        hook_dict (Dict, optional): The hook object with hook function registered on. Default value: ``None`` .
+        extra_dict (Dict, optional): The extra dict. Default value: ``None`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
     unique_id = 0
 
-    def __init__(self, hook_dict=None):
+    def __init__(self, hook_dict=None, *, extra_dict=None):
         self.hook_dict_ref = None
+        self.extra_dict_ref = None
         if hook_dict is not None:
             self.hook_dict_ref = weakref.ref(hook_dict)
             self.handle_id = HookHandle.unique_id
             HookHandle.unique_id += 1
+            if extra_dict is not None:
+                self.extra_dict_ref = weakref.ref(extra_dict)
 
     def remove(self):
         """
@@ -145,3 +149,8 @@ class HookHandle:
             hook_dict = self.hook_dict_ref()
             if hook_dict is not None and self.handle_id in hook_dict:
                 del hook_dict[self.handle_id]
+
+        if self.extra_dict_ref is not None:
+            extra_dict = self.extra_dict_ref()
+            if extra_dict is not None and self.handle_id in extra_dict:
+                del extra_dict[self.handle_id]

mindspore/common/jit_config.py

@@ -97,7 +97,7 @@ class JitConfig:
         self.jit_config_dict["debug_level"] = debug_level
         self.jit_config_dict["infer_boost"] = infer_boost
         if "backend" not in self.jit_config_dict:
-            if jit_level == "O0" or jit_level == "O1":
+            if jit_level in ["O0", "O1"]:
                 self.jit_config_dict["backend"] = "ms_backend"
             elif jit_level == "O2":
                 self.jit_config_dict["backend"] = "GE"

mindspore/common/jit_trace.py

@@ -17,16 +17,15 @@
 
 import inspect
 import re
+import types
 from functools import wraps
 import mindspore as ms
 from mindspore import log as logger
 from mindspore import context
 from mindspore.common.jit_context import JitContext, set_jit_context, jit_context
 from mindspore.common.tensor import Tensor as PythonTensor
-from mindspore._checkparam import is_stub_tensor
 from mindspore._c_expression import TraceRecorder as tr
 from mindspore._c_expression import JitExecutor_
-from mindspore._c_expression import TensorNode
 from mindspore._c_expression import TensorPy as Tensor, CSRTensor, COOTensor
 from mindspore._c_expression import typing
 
@@ -35,7 +34,7 @@ class TraceJitContext(JitContext):
     """JIT Context for trace JIT."""
 
     def __init__(self):
-        JitContext.__init__(self)
+        super().__init__()
         self._is_nested = False
 
     def set_is_nested(self, status):
@@ -44,29 +43,34 @@ class TraceJitContext(JitContext):
     def is_nested(self):
         return self._is_nested
 
+    def args_preprocess(self, prim_name, prim_res, *args):
+        args = tuple(_convert_arg_for_operators(arg, prim_name)
+                     for arg in args)
+        file_names, linenos = _get_caller_lines()
+        return prim_res, file_names, linenos, args
+
     def run_op(self, prim, prim_res, *args):
         """Capture op"""
         logger.debug(f'prim: {prim}, args: {args}, prim_res: {prim_res}')
-        if isinstance(prim_res, TensorNode):
-            prim_res = prim_res.get_value()
-        prim_res = _sync_stub_tensor(prim_res)
-        args = tuple(_sync_stub_tensor(arg) for arg in args)
-        args = tuple(_convert_arg_for_operators(arg, prim.name) for arg in args)
-        file_names, linenos = _get_caller_lines()
-        tr.get_instance().new_node(prim, prim_res, file_names, linenos, False, *args)
+        prim_res, file_names, linenos, args = self.args_preprocess(prim.name, prim_res, *args)
+        tr.get_instance().new_node(prim, (prim_res, file_names, linenos, False), *args)
         return prim_res
 
+    def prepare_op(self, prim_name, prim_res, *args):
+        """Prepare op"""
+        logger.debug(f'prim: {prim_name}, args: {args}, prim_res: {prim_res}')
+        return self.args_preprocess(prim_name, prim_res, *args)
+
     def run_graph(self, phase, prim_res, *args):
         """Capture func_graph generated from ast"""
         logger.debug(f'phase: {phase}, args: {args}, prim_res: {prim_res}')
-        if isinstance(prim_res, TensorNode):
-            prim_res = prim_res.get_value()
-        prim_res = _sync_stub_tensor(prim_res)
-        args = tuple(_sync_stub_tensor(arg) for arg in args)
         file_names, linenos = _get_caller_lines()
-        tr.get_instance().new_fg_node((phase, prim_res, file_names, linenos, self._is_nested), *args)
+        tr.get_instance().new_fg_node((prim_res, file_names, linenos, phase, self._is_nested), *args)
         return prim_res
 
+    def default_output(self):
+        return PythonTensor(0)
+
 
 _compile_only = False
 _trace_jit_context = TraceJitContext()
@@ -80,20 +84,6 @@ def _set_compile_only(compile_only=True):
     _compile_only = compile_only
 
 
-def _sync_stub_tensor(stub):
-    """Synchronize stub tensor"""
-    if is_stub_tensor(stub):
-        real_tensor = stub.stub_sync()
-        logger.debug(f'Convert stub tensor, stub: [{type(stub)}] {id(stub)}/{stub}, '
-                     f'tensor: [{type(real_tensor)}] {id(real_tensor)}/{real_tensor}')
-        return real_tensor
-    if isinstance(stub, tuple):
-        return tuple(_sync_stub_tensor(item) for item in stub)
-    if isinstance(stub, list):
-        return list(_sync_stub_tensor(item) for item in stub)
-    return stub
-
-
 def convert_tensorpy(args):
     new_args = []
     for arg in args:
@@ -129,84 +119,73 @@ def nested_run(obj, cell, *args):
     if res is not tuple:
         res = (res,)
     file_names, linenos = _get_caller_lines()
-    res = _sync_stub_tensor(res)
     set_jit_context(None)
     return file_names, linenos, res
 
 
-def _jit_trace(fn):
-    """
-    Create a callable MindSpore graph from a Python function by trace method.
-
-    This allows the MindSpore runtime to apply optimizations based on traced func graph.
-
-    Args:
-        fn (Function): The Python function that will be run as a graph. Default: ``None`` .
-
-    Returns:
-        Function, if `fn` is not None, returns a callable function that will execute the compiled function; If `fn` is
-        None, returns a decorator and when this decorator invokes with a single `fn` argument, the callable function is
-        equal to the case when `fn` is not None.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.common.jit_trace import _jit_trace as jit_trace
-        ...
-        >>> x = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
-        >>> y = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
-        ...
-        >>> # To create a callable MindSpore graph by calling decorator @jit_trace
-        >>> def tensor_add(x, y):
-        ...     z = x + y
-        ...     return z
-        ...
-        >>> tensor_add_graph = jit_trace(fn=tensor_add)
-        >>> out = tensor_add_graph(x, y)
-    """
-
-    @wraps(fn)
-    def jit_trace_wrap(*args, **kwargs):
-        # If a trace graph is already built, keep going without building a new trace graph.
-        if jit_context():
-            return fn(*args, **kwargs)
-        # Start trace process.
-        if kwargs:
-            bound_arguments = inspect.signature(fn).bind(*args, **kwargs)
-            bound_arguments.apply_defaults()
-            args = bound_arguments.args
-            kwargs = bound_arguments.kwargs
-        generate_name = fn.__module__
-        if args:
-            jit_args = args[1:] if hasattr(args[0], fn.__name__) else args
-            obj = args[0]
-            if hasattr(obj, fn.__name__):  # Add class name for Cell.
-                generate_name = generate_name + "." + obj.__class__.__name__
-        else:
-            jit_args = args
-        generate_name = generate_name + "." + fn.__name__ + "#" + str(id(fn))
-        # Add create time for Cell.
-        if args and hasattr(obj, fn.__name__):
-            generate_name = generate_name + '#created_' + str(args[0].create_time)
-        line_str = fn.__code__.co_filename + ":" + str(fn.__code__.co_firstlineno)
-        generate_name = generate_name + '#[' + line_str + ']'
-
-        new_compile = _jit_trace_begin(generate_name, *jit_args)
-        if new_compile:
-            fn_res = fn(*args, **kwargs)
-            logger.debug(f'fn: {fn}, fn_res: {fn_res}, line: {line_str}')
-            # Use fn's output to build func graph's output.
-            output = _jit_trace_end(fn_res)
-        else:
-            output = _jit_trace_end(None)  # Run with compilation.
-        logger.debug(f'output: {output}')
-        return output
-
-    jit_trace_wrap.__trace_func__ = True
-    return jit_trace_wrap
+def _jit_trace():
+    """Return the wrapped function for trace mode jit."""
+    def wrap_func(fn):
+        if hasattr(fn, "construct"):
+            if isinstance(fn, ms.nn.Cell):
+                # Bound the cell object to get the self arg.
+                return types.MethodType(_jit_trace()(fn.construct.__func__), fn)
+            if isinstance(fn, type) and issubclass(fn, ms.nn.Cell):
+                fn.construct = _jit_trace()(fn.construct)
+            return fn
+
+        if isinstance(fn, types.MethodType):
+            return types.MethodType(_jit_trace()(fn.__func__), fn.__self__)
+
+        if not isinstance(fn, types.FunctionType):
+            logger.warning(f"The fn should be function, method or cell instance/class, but got {fn}")
+            return fn
+
+        if hasattr(fn, "__wrapped_by_jit__"):
+            logger.warning(f"The fn {fn} should be wrapped by jit only once.")
+
+        @wraps(fn)
+        def jit_trace_wrap(*args, **kwargs):
+            # If a trace graph is already built, keep going without building a new trace graph.
+            if jit_context():
+                return fn(*args, **kwargs)
+            # Start trace process.
+            if kwargs:
+                bound_arguments = inspect.signature(fn).bind(*args, **kwargs)
+                bound_arguments.apply_defaults()
+                args = bound_arguments.args
+                kwargs = bound_arguments.kwargs
+            generate_name = fn.__module__
+            if args:
+                jit_args = args[1:] if hasattr(args[0], fn.__name__) else args
+                obj = args[0]
+                if hasattr(obj, fn.__name__):  # Add class name for Cell.
+                    generate_name = generate_name + "." + obj.__class__.__name__
+            else:
+                jit_args = args
+            generate_name = generate_name + "." + fn.__name__ + "#" + str(id(fn))
+            # Add create time for Cell.
+            if args and hasattr(obj, fn.__name__):
+                generate_name = generate_name + '#created_' + str(args[0].create_time)
+            line_str = fn.__code__.co_filename + ":" + str(fn.__code__.co_firstlineno)
+            generate_name = generate_name + '#[' + line_str + ']'
+
+            new_compile = _jit_trace_begin(generate_name, *jit_args)
+            if new_compile:
+                fn_res = fn(*args, **kwargs)
+                logger.debug(f'fn: {fn}, fn_res: {fn_res}, line: {line_str}')
+                # Use fn's output to build func graph's output.
+                output = _jit_trace_end(fn_res)
+            else:
+                output = _jit_trace_end(None)  # Run with compilation.
+            logger.debug(f'output: {output}')
+            return output
+
+        jit_trace_wrap.__trace_func__ = True
+        setattr(jit_trace_wrap, "__wrapped_by_jit__", True)
+        return jit_trace_wrap
+
+    return wrap_func
 
 
 def _get_caller_lines():
@@ -240,6 +219,8 @@ def _get_args_for_run(args):
             new_args.append(arg)
         elif isinstance(arg, dict) and hasattr(arg, "__ms_mutable__"):
             new_args.append(tuple(arg.values()))
+        elif isinstance(arg, (tuple, list)) and hasattr(arg, "__ms_mutable__"):
+            new_args.append(arg)
     return tuple(new_args)
 
 
@@ -284,7 +265,6 @@ def _jit_trace_begin(fn_name, *args):
     logger.debug(f'_jit_trace_begin, args: {args}')
     _trace_jit_context.set_is_nested(False)
     set_jit_context(_trace_jit_context)
-    args = tuple(_sync_stub_tensor(arg) for arg in args)
     for arg in args:
         logger.debug(f'_jit_trace_begin, arg: {arg}, {type(arg)}')
 
@@ -355,7 +335,6 @@ def _jit_trace_end(*output_args):
         logger.debug(f'jit trace result: {output}')
     else:
         logger.debug(f'output_args: {output_args}')
-        output_args = tuple(_sync_stub_tensor(arg) for arg in output_args)
         file_names, linenos = _get_caller_lines()
         tr.get_instance().end_graph(file_names, linenos, *output_args)
         if _compile_only:

mindspore/common/parameter.py

@@ -49,17 +49,37 @@ import mindspore.common._monad as monad
 __all__ = ['Parameter', 'ParameterTuple']
 
 PARAMETER_NAME_DEFAULT = "Parameter"
+_GENERATED_PARAMETER_NAME_PREFIX = PARAMETER_NAME_DEFAULT + '#'
 PARAMETER_NAME_PREFIX_MAX_LEN = 1024
 
+_PARAMETER_NAME_ID = 0
+
+
+def _generate_parameter_name():
+    global _PARAMETER_NAME_ID
+    name = _GENERATED_PARAMETER_NAME_PREFIX + str(_PARAMETER_NAME_ID)
+    _PARAMETER_NAME_ID += 1
+    return name
+
+
+def _is_parameter_generated(param_name):
+    if not param_name or not isinstance(param_name, str):
+        return False
+    return param_name.startswith(_GENERATED_PARAMETER_NAME_PREFIX)
+
+
 # Global variable for parameter unique key.
 _GLOBAL_PARAMETER_KEY = -1
 
 # Global variable to mark the hook of parameter is updated
 _parameter_hook_updated = True
+
+
 def set_parameter_hook_updated(value):
     global _parameter_hook_updated
     _parameter_hook_updated = value
 
+
 def parameter_hook_updated():
     global _parameter_hook_updated
     return _parameter_hook_updated
@@ -496,11 +516,11 @@ class Parameter(Tensor_):
                 the default value `PARAMETER_NAME_DEFAULT` is used.
         """
         if name_ is None:
-            name_ = PARAMETER_NAME_DEFAULT
+            name_ = _generate_parameter_name()
         elif isinstance(name_, str):
             name_ = name_.strip()
             if name_ == '':
-                name_ = PARAMETER_NAME_DEFAULT
+                name_ = _generate_parameter_name()
             if len(name_) > PARAMETER_NAME_PREFIX_MAX_LEN:
                 raise ValueError("The length of the '{}' name should be less than {}.".
                                  format(name_, PARAMETER_NAME_PREFIX_MAX_LEN))
@@ -904,13 +924,10 @@ class Parameter(Tensor_):
         incoming_tensor_is_init = isinstance(data, Tensor) and not data.has_init
         current_tensor_is_init = isinstance(self, Tensor) and not self.has_init
         if self.dtype != data.dtype:
-            if mstype.implicit_conversion_seq.get(self.dtype) < mstype.implicit_conversion_seq.get(data.dtype):
-                self._raise_type_error(data.dtype)
-            else:
-                from mindspore.ops import functional as F
-                if isinstance(data, Tensor) and data.init is not None:
-                    data.init_data()
-                data = F.cast(data, self.dtype)
+            from mindspore.ops import functional as F
+            if isinstance(data, Tensor) and data.init is not None:
+                data.init_data()
+            data = F.cast(data, self.dtype)
         if isinstance(data, Tensor) and data.has_init:
             # The parameter has been initialized, directly update by the data
             if current_tensor_is_init:
@@ -938,7 +955,6 @@ class Parameter(Tensor_):
             init_data_args += (slice_index, layout[2], layout[5])
         return init_data_args
 
-
     def init_data(self, layout=None, set_sliced=False):
         """
         Initialize the parameter's data.
@@ -1030,7 +1046,6 @@ class Parameter(Tensor_):
         """
         return Tensor_._offload(self, True)
 
-
     def _load(self):
         r"""
         Load parameter to device.
@@ -1160,6 +1175,5 @@ class ParameterTuple(tuple):
                 _insert_accumu_init_info(x1.name, init_to_value(init))
         return ParameterTuple(new)
 
-
     def __parameter_tuple__(self):
         """For parse check."""

mindspore/common/recompute.py

@@ -25,7 +25,7 @@ from mindspore.ops.composite import GradOperation
 from mindspore.common._register_for_recompute import recompute_registry
 from mindspore.common.api import _pynative_executor, _no_grad
 from mindspore.common.generator import get_rng_state, set_rng_state
-from mindspore.train.amp import amp_decorator
+from mindspore.train.amp import AmpDecorator
 from mindspore._c_expression.amp import get_curr_amp_strategy
 
 
@@ -104,8 +104,8 @@ class _RecomputeCell(Cell):
             set_rng_state(self.cpu_rng_state)
             _pynative_executor.set_is_run_recompute(True)
             if self.amp_strategy:
-                with amp_decorator(self.amp_strategy.get_amp_level(), self.amp_strategy.get_amp_dtype(),
-                                   self.amp_strategy.get_white_list(), self.amp_strategy.get_black_list()):
+                with AmpDecorator(self.amp_strategy.get_amp_level(), self.amp_strategy.get_amp_dtype(),
+                                  self.amp_strategy.get_white_list(), self.amp_strategy.get_black_list()):
                     grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)
             else:
                 grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)

mindspore/common/sparse_tensor.py

@@ -98,7 +98,6 @@ class RowTensor(RowTensorInner):
 
     .. warning::
         - This is an experimental API that is subjected to change or deletion.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
 
     Args:
         indices (Tensor): A 1-D integer Tensor of shape :math:`(d_0)` . Default: ``None``.
@@ -232,7 +231,6 @@ class COOTensor(COOTensor_):
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - Currently, duplicate coordinates in the indices will not be coalesced.
           If the indices contain out-of-bound values, the result will be undefined.
 
@@ -681,7 +679,6 @@ class CSRTensor(CSRTensor_):
 
     .. warning::
         - This is an experimental API that is subjected to change.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - If the values given by `indptr` or `indices` are invalid, the results may be undefined. Invalid values include
           when the length of `values` or `indices` exceeds the range indicated by `indptr`, and when the columns
           indicated by `indices` are repeated on the same row.

mindspore/common/symbol.py

@@ -104,7 +104,6 @@ class Symbol:
         if not isinstance(unique, bool):
             raise TypeError(f"For 'Symbol', the argument 'unique' must be bool, but got {type(unique)}")
 
-    # pylint: disable=missing-docstring
     def to_dict(self):
         # Convert the symbolic info to dictionary.
         # This method is not necessary to show in public api document, use comment instead of docstring.