mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc2__cp38-cp38-manylinux1_x86_64.whl

mindspore/common/api.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2023 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -40,7 +40,7 @@ from mindspore.common.sparse_tensor import COOTensor as PythonCOOTensor
 from mindspore.common.sparse_tensor import RowTensor as PythonRowTensor
 from mindspore._c_expression import GraphExecutor_, Tensor, CSRTensor, RowTensor, COOTensor, \
     PyNativeExecutor_, verify_inputs_signature, init_exec_dataset, _set_dataset_mode_config, init_pipeline, \
-    _ms_memory_recycle, _bind_device_ctx
+    _ms_memory_recycle, _bind_device_ctx, jit_mode_pi_enable, jit_mode_pi_compile
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.parallel._utils import _check_full_batch, _get_parameter_broadcast, _is_pynative_parallel, \
     _is_in_auto_parallel_mode
@@ -52,6 +52,7 @@ from mindspore.common._register_for_adapter import ms_adapter_registry
 from mindspore.common.auto_dynamic_shape import get_auto_dynamic_shape_args, update_auto_dynamic_shape_phase, \
     get_auto_dynamic_shape_args_with_check_input_signature, update_auto_dynamic_shape_phase_with_check_input_signature
 
+
 # Store ms_function class compiled pipeline cache.
 ms_compile_cache = set()
 # Store cell compiled pipeline cache.
@@ -63,6 +64,14 @@ BROADCAST_PHASE = "_broadcast_"
 _PYNATIVE_PARALLEL_FUNC_NAME = "after_shard"
 
 
+def _ms_adapter_tensor_as_parameter_output(data):
+    """Check whether the data is an output from a parameter which is a ms_adapter tensor.
+       Pylint: disable=unidiomatic-typecheck.
+    """
+    return ms_adapter_registry.is_registered and isinstance(data, ms_adapter_registry.tensor) \
+           and hasattr(data, "__ms_parameter_output__") and getattr(data, "__ms_parameter_output__")
+
+
 def _convert_python_data(data):
     """
     Convert C++ data to python.
@@ -73,8 +82,10 @@ def _convert_python_data(data):
     Returns:
         data, a data convert C++ to python
     """
-    if isinstance(data, Tensor) and data.adapter_flag:
+    if isinstance(data, (Tensor, PythonTensor)) and data.adapter_flag:
         return ms_adapter_registry.tensor(data)
+    if _ms_adapter_tensor_as_parameter_output(data):
+        return data.tensor
     if isinstance(data, Tensor) and not isinstance(data, PythonTensor):
         return PythonTensor(data, internal=True)
     if isinstance(data, CSRTensor) and not isinstance(data, PythonCSRTensor):
@@ -83,7 +94,7 @@ def _convert_python_data(data):
         return PythonCOOTensor(coo_tensor=data)
     if isinstance(data, RowTensor) and not isinstance(data, PythonRowTensor):
         return PythonRowTensor(row_tensor=data)
-    if isinstance(data, tuple):
+    if data.__class__ is tuple:
         # Handle namedtuple since its type is tuple.
         if hasattr(data, "_fields"):
             type_name = data.__class__.__name__
@@ -91,12 +102,12 @@ def _convert_python_data(data):
             fields = data_dict.keys()
             return namedtuple(type_name, fields)(**_convert_python_data(data_dict))
         return tuple(_convert_python_data(x) for x in data)
-    if isinstance(data, list):
+    if data.__class__ is list:
         # Keep list object not change for inplace operation.
         for i in range(len(data)):
             data[i] = _convert_python_data(data[i])
         return data
-    if isinstance(data, dict):
+    if data.__class__ is dict:
         # Keep the dict object not change.
         keys = tuple(data.keys())
         for key in keys:
@@ -260,7 +271,7 @@ def _get_parameter_layout():
     return layout
 
 
-def _handle_arg(obj, arg):
+def _handle_arg(obj, arg, compile_arg):
     """Handle arg for runtime .If need handle the arg, return True"""
     if isinstance(arg, PythonTensor):
         if arg.has_init:
@@ -269,7 +280,7 @@ def _handle_arg(obj, arg):
             return arg
     elif isinstance(arg, (Tensor, CSRTensor, COOTensor)):
         return arg
-    elif hasattr(arg, "__ms_mutable__") and getattr(arg, "__ms_mutable__"):
+    elif compile_arg is not None and hasattr(compile_arg, "__ms_mutable__") and getattr(compile_arg, "__ms_mutable__"):
         # mutable([]) will be eliminated by FuncGraphSpecializer, and empty list is not supported by backend.
         if isinstance(arg, list) and not arg:
             return None
@@ -282,16 +293,54 @@ def _handle_arg(obj, arg):
     return None
 
 
-def _get_args_for_run(obj, args, kwargs):
+def _handle_arg_predict(obj, arg, compile_arg):
+    """Handle arg for runtime .If need handle the arg, return True"""
+    if arg is None:
+        return None
+
+    if isinstance(arg, (int, float)):
+        return None
+
+    if isinstance(arg, (list, tuple)):
+        if compile_arg is not None and hasattr(compile_arg, "__ms_mutable__") and \
+                getattr(compile_arg, "__ms_mutable__"):
+            # mutable([]) will be eliminated by FuncGraphSpecializer, and empty list is not supported by backend.
+            if isinstance(arg, list) and not arg:
+                return None
+            return arg
+        if hasattr(obj, "enable_tuple_broaden") and obj.enable_tuple_broaden and isinstance(arg, tuple) and \
+                _check_all_tensor(arg):
+            return arg
+        return None
+    return arg
+
+
+def _get_args_for_run(obj, args, kwargs, compile_args):
+    """Get the actual input args and kwargs for runtime."""
+    new_args = []
+    for arg, compile_arg in zip(args, compile_args):
+        new_arg = _handle_arg(obj, arg, compile_arg)
+        if new_arg is not None:
+            new_args.append(new_arg)
+
+    for _, value in kwargs.items():
+        new_value = _handle_arg(obj, value, None)
+        if new_value is not None:
+            new_args.append(new_value)
+
+    return new_args
+
+
+def _get_args_for_run_predict(obj, args, kwargs, compile_args):
     """Get the actual input args and kwargs for runtime."""
     new_args = []
-    for arg in args:
-        new_arg = _handle_arg(obj, arg)
+    for arg, compile_arg in zip(args, compile_args):
+        new_arg = _handle_arg_predict(obj, arg, compile_arg)
         if new_arg is not None:
             new_args.append(new_arg)
 
     for _, value in kwargs.items():
-        new_value = _handle_arg(obj, value)
+        new_value = _handle_arg_predict(obj, value, None)
         if new_value is not None:
             new_args.append(new_value)
 
@@ -329,6 +378,7 @@ class _MindsporeFunctionExecutor:
         self.enable_tuple_broaden = False
         self._graph_executor = GraphExecutor_.get_instance()
         self._create_time = ms_create_time
+        self._compile_args = None
         self.jit_config_dict = jit_config.jit_config_dict if jit_config else None
 
 
@@ -376,6 +426,7 @@ class _MindsporeFunctionExecutor:
 
         # Restore the mutable attr for every arg.
         compile_args = _restore_mutable_attr(args, compile_args)
+        self._compile_args = compile_args
         generate_name, echo_function_name = self._get_generate_name()
         # The full Function name
         full_function_name = generate_name
@@ -414,6 +465,9 @@ class _MindsporeFunctionExecutor:
         update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, self.input_signature)
 
         if phase in ms_compile_cache:
+            # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
+            # generated in generate_arguments_key.
+            self._graph_executor.clear_compile_arguments_resource()
             return phase
 
         self._check_recompile(full_function_name, create_time, echo_function_name)
@@ -448,7 +502,9 @@ class _MindsporeFunctionExecutor:
 
         return phase
 
-    def _check_recompile(self, full_function_name, create_time, echo_function_name):
+
+    @staticmethod
+    def _check_recompile(full_function_name, create_time, echo_function_name):
         """Warning when the function has been compiled."""
         ignore_dirs = ["mindspore/ops", "mindspore/nn"]
         if any((lambda x: x in full_function_name)(x) for x in ignore_dirs):
@@ -529,6 +585,7 @@ class _MindsporeFunctionExecutor:
             for i, elem in enumerate(compile_args):
                 if isinstance(elem, PythonTensor):
                     Validator.check_dynamic_shape(compile_args[i], args_list[i], i)
+            Validator.check_symbolic_shape(compile_args, args_list)
 
         # Case: If dynamic shape tensors have been assigned to `input_signature`, they are preferred as compile args.
         if self.input_signature is not None:
@@ -540,6 +597,7 @@ class _MindsporeFunctionExecutor:
                 if isinstance(elem, PythonTensor) and is_shape_unknown(elem.shape):
                     Validator.check_dynamic_shape(self.input_signature[i], args_list[i], i)
                     dyn_shape = True
+            Validator.check_symbolic_shape(self.input_signature, args_list)
             if dyn_shape:
                 # Checkout whether the `sens` has been added to args_list.
                 if len(self.input_signature) == len(args_list) - 1:
@@ -568,7 +626,7 @@ class _MindsporeFunctionExecutor:
         Returns:
             new_inputs, new input args, which are required for running.
         """
-        return _get_args_for_run(self, args_list, kwargs)
+        return _get_args_for_run(self, args_list, kwargs, self._compile_args)
 
 
 # The attributes used to identify a given object.
@@ -596,18 +654,19 @@ def _get_jit_hash(hash_input):
     return _get_obj_id(hash_input)
 
 
-def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_once=False):
+def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=None, compile_once=False):
     """
     Create a callable MindSpore graph from a Python function.
 
     This allows the MindSpore runtime to apply optimizations based on graph.
 
-    Note:
-        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
-        will not accept `**kwargs`.
-
     Args:
         fn (Function): The Python function that will be run as a graph. Default: ``None`` .
+        mode (str): The type of jit used, the value of mode should be ``PIJit`` or ``PSJit``. Default: ``PSJit`` .
+
+            - `PSJit <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html>`_ : MindSpore GRAPH_MODE.
+            - `PIJit <https://www.mindspore.cn/docs/en/master/design/dynamic_graph_and_static_graph.html>`_ : MindSpore PYNATIVE_MODE.
+
         input_signature (Tensor): The Tensor which describes the input arguments. The shape and dtype of the Tensor
             will be supplied to this function. If input_signature is specified, each input to `fn` must be a `Tensor`.
             And the input parameters of `fn` cannot accept `**kwargs`. The shape and dtype of actual inputs should
@@ -618,9 +677,13 @@ def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_
         jit_config (JitConfig): Jit config for compile. Default: ``None`` .
         compile_once(bool): ``True``: The function would be compiled once when it was created many times.
             But it may be wrong if the free variables were changed. ``False`` : It would be recompiled when
-            it was created again
+            it was created again.
             Default: ``False`` .
 
+    Note:
+        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
+        will not accept `**kwargs`.
+
     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
@@ -720,9 +783,43 @@ def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_
 
         return staging_specialize
 
+    def pi_wrap_mindspore(decorated):
+        func = decorated
+        if isinstance(func, ms.nn.Cell):
+            func = func.construct
+        if isinstance(func, type) and issubclass(func, ms.nn.Cell):
+            func = func.construct
+        if isinstance(func, types.MethodType):
+            func = func.__func__
+        if not isinstance(func, types.FunctionType):
+            logger.warning("only support function and mindspore.nn.Cell instance")
+            return decorated
+
+        # generator, coroutine, awaitable and a function that return them is unsupported
+        UNSUPPORTED_CODE_TYPE = (inspect.CO_GENERATOR | inspect.CO_COROUTINE |
+                                 inspect.CO_ASYNC_GENERATOR | inspect.CO_ITERABLE_COROUTINE)
+        if func.__code__.co_flags & UNSUPPORTED_CODE_TYPE:
+            return decorated
+
+        config = dict()
+        if isinstance(jit_config, JitConfig):
+            config.update(jit_config.jit_config_dict)
+        elif jit_config is not None:
+            config.update(jit_config)
+        jit_mode_pi_enable()
+
+        if jit_mode_pi_compile(func, config) is False:
+            logger.warning('add fn {} to compile failed '.format(func))
+
+        return decorated
+
+    wrap_func = wrap_mindspore
+    if mode == "PIJit":
+        wrap_func = pi_wrap_mindspore
+
     if fn is not None:
-        return wrap_mindspore(fn)
-    return wrap_mindspore
+        return wrap_func(fn)
+    return wrap_func
 
 
 def ms_function(fn=None, input_signature=None, hash_args=None, jit_config=None):
@@ -732,15 +829,14 @@ def ms_function(fn=None, input_signature=None, hash_args=None, jit_config=None):
     This allows the MindSpore runtime to apply optimizations based on graph.
 
     Note:
-        `ms_function` will be deprecated and removed in a future version. Please use `jit` instead.
-        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
-        will not accept `**kwargs`.
+        - `ms_function` will be deprecated and removed in a future version. Please use :func:`mindspore.jit` instead.
+        - If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
+          will not accept `**kwargs`.
 
     Args:
         fn (Function): The Python function that will be run as a graph. Default: ``None`` .
         input_signature (Tensor): The Tensor which describes the input arguments. The shape and dtype of the Tensor
-            will be supplied to this function. If input_signature is specified, each input to `fn` must be a `Tensor`.
-            And the input parameters of `fn` cannot accept `**kwargs`. The shape and dtype of actual inputs should
+            will be supplied to this function. The shape and dtype of actual inputs of `fn` should
             keep the same as input_signature. Otherwise, TypeError will be raised. Default: ``None`` .
         hash_args (Union[Object, List or Tuple of Objects]): The local free variables used inside `fn`,
             like functions or objects of class defined outside `fn`. Calling `fn` again with change of `hash_args`
@@ -909,7 +1005,7 @@ def ms_class(cls):
     This allows MindSpore to identify user-defined classes and thus obtain their attributes and methods.
 
     Note:
-        `ms_class` will be deprecated and removed in a future version. Please use `jit_class` instead.
+        `ms_class` will be deprecated and removed in a future version. Please use :func:`mindspore.jit_class` instead.
 
     Args:
         cls (Class): User-defined class.
@@ -1037,6 +1133,8 @@ def set_adapter_config(config):
             ms_adapter_registry.register_parameter(value)
         elif key == "convert_object_map":
             ms_adapter_registry.register_convert_map(value)
+        elif key == "convert_adapter_tensor_map":
+            ms_adapter_registry.register_convert_adapter_tensor_map(value)
         else:
             raise ValueError(f"Unsupported key in adapter config: {key}")
 
@@ -1135,16 +1233,6 @@ class _PyNativeExecutor:
         self._executor = PyNativeExecutor_.get_instance()
         self._executor.set_py_exe_path(sys.executable)
         self._executor.set_kernel_build_server_dir(os.path.split(kernel_build_server.__file__)[0] + os.sep)
-        self._top_cell = None
-
-    def __call__(self):
-        """
-        PyNative executor run grad graph.
-
-        Return:
-            The return object after running grad graph.
-        """
-        return self._executor()
 
     @staticmethod
     def parameter_broadcast(obj, phase):
@@ -1246,7 +1334,7 @@ class _PyNativeExecutor:
         Return:
             None.
         """
-        self._executor.grad_net(grad, obj, weights, grad_position, *args, *(kwargs.values()))
+        return self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
 
     def clear_res(self):
         """
@@ -1333,6 +1421,17 @@ class _PyNativeExecutor:
         """
         self._executor.set_jit_compile_status(status, phase)
 
+    def set_is_run_recompute(self, status):
+        """
+        Set recompute grad is compiling
+
+        Args:
+            status(bool): grad is in recompute status
+        Return:
+            None.
+        """
+        self._executor.set_is_run_recompute(status)
+
     def set_dynamic_input(self, obj, *args):
         """
         Set dynamic shape tensor of input arguments.
@@ -1380,15 +1479,6 @@ class _PyNativeExecutor:
         """
         self._executor.set_hook_changed(cell)
 
-    def get_top_cell(self):
-        """
-        Get the top cell object.
-
-        Return:
-            The top cell object.
-        """
-        return self._top_cell
-
     def constant_folding(self, *args):
         """
         Get value by infer value.
@@ -1493,7 +1583,7 @@ class _CellGraphExecutor:
         enable_compile_cache = context.get_context("enable_compile_cache")
         if enable_compile_cache is not True and enable_compile_cache != "1":
             enable_compile_cache = os.getenv('MS_COMPILER_CACHE_ENABLE')
-        if "train" in phase and (enable_compile_cache is True or enable_compile_cache == "1"):
+        if enable_compile_cache is True or enable_compile_cache == "1":
             self._graph_executor.set_compile_cache_dep_files(_get_compile_cache_dep_files())
 
     def compile(self, obj, *args, phase='predict', do_convert=True, jit_config_dict=None, **kwargs):
@@ -1522,15 +1612,20 @@ class _CellGraphExecutor:
         self.enable_tuple_broaden = False
         if hasattr(obj, "enable_tuple_broaden"):
             self.enable_tuple_broaden = obj.enable_tuple_broaden
-        logger.debug("Convert the network.", do_convert)
+        logger.debug(f"Convert the network: {do_convert}.")
         self._graph_executor.set_enable_tuple_broaden(self.enable_tuple_broaden)
         key = self._graph_executor.generate_arguments_key(obj, args, kwargs, self.enable_tuple_broaden)
         obj.arguments_key = str(key)
+        raw_phase = phase
         phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
+        obj.phase_cache[raw_phase] = phase
         update_auto_dynamic_shape_phase(args, key_id, phase)
 
         if phase in obj.compile_cache and self.has_compiled(phase):
             logger.debug("%r graph has existed.", phase)
+            # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
+            # generated in generate_arguments_key.
+            self._graph_executor.clear_compile_arguments_resource()
             return phase, False
 
         obj.check_names()

mindspore/common/auto_dynamic_shape.py

@@ -182,15 +182,15 @@ class _AutoDynamicShapeManager:
 
     def _compare_input_args_and_cache_args(self, input_args, cache_args):
         """compare input args and cache args"""
-        for (input, cache) in zip(input_args, cache_args):
-            if isinstance(input, Tensor) and isinstance(cache, Tensor):
-                if not self.is_tensor_equal(input, cache):
+        for (arg, cache) in zip(input_args, cache_args):
+            if isinstance(arg, Tensor) and isinstance(cache, Tensor):
+                if not self.is_tensor_equal(arg, cache):
                     return False
-            elif isinstance(input, int) and isinstance(cache, int):
-                if input != cache:
+            elif isinstance(arg, int) and isinstance(cache, int):
+                if arg != cache:
                     return False
-            elif isinstance(input, (tuple, list)) and isinstance(cache, (tuple, list)):
-                if not self._compare_input_args_and_cache_args(input, cache):
+            elif isinstance(arg, (tuple, list)) and isinstance(cache, (tuple, list)):
+                if not self._compare_input_args_and_cache_args(arg, cache):
                     return False
         return True
 
@@ -287,21 +287,21 @@ class _AutoIdentifyDynamicShape:
 
 
     @staticmethod
-    def _do_generalize_in_sink(arg, cache, input_index, cache_index, cache_type):
+    def _do_generalize_in_sink(input_arg, cache, input_index, cache_index, cache_type):
         """do generalize in sink, input rank must be 2"""
-        if not arg:
+        if not input_arg:
             raise ValueError("In sink mode, cell input can not be scalar.")
 
-        if arg == cache:
+        if input_arg == cache:
             return cache
 
         shape_value = []
-        if len(arg) != len(cache):
+        if len(input_arg) != len(cache):
             shape_value.append(SHAPE_RANK_ANY)
         else:
-            for _ in arg:
+            for _ in input_arg:
                 shape_value.append(SHAPE_DIM_ANY)
-        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {arg},'
+        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {input_arg},'
                      f'cache shape is {cache}, not equal, need generalize to {shape_value}.'))
         return shape_value
 
@@ -312,6 +312,20 @@ class _AutoIdentifyDynamicShape:
         self.auto_dynamic_shape_manager.update_phase_and_compile_args(args, phase, self.save_cache_number,
                                                                       is_sink_mode, aux)
 
+    def _check_real_shape_cache(self, res_shape, args_list):
+        """find cache in real_shape_cache"""
+        real_cache_number = self.auto_dynamic_shape_manager.get_real_shape_cache_number()
+        if real_cache_number < 2:
+            logger.info((f'real shape cache cap is {real_cache_number}, smaller than 2, '
+                         f'compile args shape={res_shape}.'))
+            return True
+
+        is_real_shape_exist = self.auto_dynamic_shape_manager.find_compile_args_in_shape_cache(args_list, "real")
+        if is_real_shape_exist:
+            logger.debug((f'find compile args in real shape cache, compile args shape={res_shape}'))
+            return True
+
+        return False
 
     def _generate_with_generalize_shape(self, generalize_shape_args, is_sink_mode, args_list):
         """generate with generalize_shape """
@@ -440,7 +454,6 @@ class _AutoIdentifyDynamicShape:
         return generalize_one_shape, True
 
 
-
     def _do_generalize_shape(self, cache_type, input_args, is_sink_mode):
         """do generalize shape by cache"""
         shape_cache = self.auto_dynamic_shape_manager.get_cache_by_type(cache_type)

mindspore/common/dtype.py

@@ -43,7 +43,7 @@ __dtype__ = [
     "TensorType", "_null",
     "Type", "Int",
     "complex64", "complex128",
-    "bfloat16"
+    "bfloat16", "qint4x2"
 ]
 
 __method__ = [
@@ -58,6 +58,7 @@ __all__.extend(__method__)
 # type definition
 bool_ = typing.Bool()
 
+qint4x2 = typing.Int(4)
 int8 = typing.Int(8)
 byte = int8
 int16 = typing.Int(16)
@@ -140,11 +141,12 @@ number_type = (int8,
                float64,
                bfloat16,
                complex64,
-               complex128,)
+               complex128,
+               qint4x2,)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64,)
+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)
@@ -348,8 +350,9 @@ class QuantDtype(enum.Enum):
     """
     An enum for quant datatype, contains `INT1` ~ `INT16`, `UINT1` ~ `UINT16`.
 
-    `QuantDtype` is defined in `dtype.py <https://gitee.com/mindspore/mindspore/tree/r2.2/mindspore/python/mindspore/
-    common/dtype.py>`_, use command below to import:
+    `QuantDtype` is defined in
+    `dtype.py <https://gitee.com/mindspore/mindspore/blob/master/mindspore/python/mindspore/common/dtype.py>`_ ,
+    use command below to import:
 
     .. code-block::
 
@@ -357,7 +360,7 @@ class QuantDtype(enum.Enum):
 
     Tutorial Examples:
         - `Quantization algorithm in Golden Stick
-          <https://www.mindspore.cn/golden_stick/docs/en/r0.3/quantization/slb.html
+          <https://www.mindspore.cn/golden_stick/docs/en/master/quantization/slb.html
           #applying-the-quantization-algorithm>`_
     """
     INT1 = 0

mindspore/common/dump.py

@@ -26,12 +26,13 @@ def set_dump(target, enabled=True):
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
     Please note that this API takes effect only when Asynchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document <https://www.mindspore.cn/tutorials/
-    experts/en/r2.2/debug/dump.html>`_ for details. The default enabled status for
+    field in dump config file is ``"2"`` . See the `dump document
+    <https://www.mindspore.cn/tutorials/experts/en/master/debug/dump.html>`_ for details.
+    The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
+        This is an experimental API that is subject to change or deletion. It is not supported for 2.3 version.
 
     Note:
         1. This API is only effective for GRAPH_MODE with Ascend backend.
@@ -60,7 +61,7 @@ def set_dump(target, enabled=True):
         .. note::
             Please set environment variable `MINDSPORE_DUMP_CONFIG` to the dump config file and set `dump_mode` field
             in dump config file to 2 before running this example.
-            See `dump document <https://www.mindspore.cn/tutorials/experts/en/r2.2/debug/dump.html>`_ for details.
+            See `dump document <https://www.mindspore.cn/tutorials/experts/en/master/debug/dump.html>`_ for details.
 
         >>> import numpy as np
         >>> import mindspore as ms

mindspore/common/hook_handle.py

@@ -14,9 +14,58 @@
 # ============================================================================
 """The removable handle for cell hook function."""
 from __future__ import absolute_import
-
 import weakref
-from mindspore.common.api import _pynative_executor
+from mindspore._c_expression import Tensor as Tensor_
+
+
+class _TensorHookHandle:
+    r"""
+    A handle provides the ability to remote a tensor hook.
+
+    Note:
+        It is only supported in pynative mode and works when registering or removing hook function for tensor
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+
+    def __init__(self):
+        self.id = None
+
+    def remove(self):
+        """
+        Remove the tensor hook function, which corresponds to this '_TensorHookHandle' object.
+
+        Args:
+            None.
+
+        Returns:
+            None.
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> ms.set_context(mode=ms.PYNATIVE_MODE)
+            >>> def hook_fn(grad):
+            ...     return grad * 2
+            ...
+            >>> def hook_test(x, y):
+            ...     z = x * y
+            ...     handle = z.register_hook(hook_fn)
+            ...     z = z * y
+            ...     handle.remove()
+            ...     return z
+            ...
+            >>> ms_grad = ms.grad(hook_test, grad_position=(0,1))
+            >>> output = ms_grad(Tensor(1, ms.float32), Tensor(2, ms.float32))
+            >>> print(output)
+            (Tensor(shape=[], dtype=Float32, value=4), Tensor(shape=[], dtype=Float32, value=4))
+        """
+        if self.id is not None:
+            Tensor_.remove_hook(self.id)
 
 
 class HookHandle:
@@ -100,9 +149,7 @@ class HookHandle:
             hook_cell = self._hook_cell()
             if self._hook_type == "_forward_pre_hook" and self._hook_key in hook_cell._forward_pre_hook:
                 del hook_cell._forward_pre_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
             elif self._hook_type == "_forward_hook" and self._hook_key in hook_cell._forward_hook:
                 del hook_cell._forward_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
             elif self._hook_type == "_cell_backward_hook":
                 hook_cell._cell_backward_hook.remove_backward_hook(self._hook_key)

mindspore/common/initializer.py

@@ -37,7 +37,7 @@ class Initializer:
         Initializers are intended to be used for delayed initialization in parallel mode rather than Tensor
         initialization. If you have to use Initializers to create a Tensor, :func:`mindspore.Tensor.init_data` should be
         followed in most of the cases. For more information, please refer to `mindspore.Tensor.init_data
-        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
+        <https://www.mindspore.cn/docs/en/master/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
         mindspore-tensor-init-data>`_ .
 
     Args: