mindspore 2.3.0rc1__cp39-cp39-manylinux1_x86_64.whl → 2.3.0rc2__cp39-cp39-manylinux1_x86_64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = '[sha1]:d8944576,[branch]:(HEAD,origin/r2.3.q1,r2.3.q1)'
+__commit_id__ = '[sha1]:c6a1400a,[branch]:(HEAD,origin/master,origin/HEAD,master)'

mindspore/__init__.py

@@ -30,7 +30,7 @@ from mindspore.version import __version__
 from mindspore.profiler import Profiler, EnvProfiler
 from mindspore.parallel import set_algo_parameters, get_algo_parameters, reset_algo_parameters, \
     rank_list_for_transform, transform_checkpoint_by_rank, transform_checkpoints, merge_pipeline_strategys, shard, \
-    Layout, sync_pipeline_shared_parameters, parameter_broadcast
+    Layout, sync_pipeline_shared_parameters, parameter_broadcast, load_segmented_checkpoints
 from mindspore.rewrite import SymbolTree, ScopedValue, Node, NodeType
 from mindspore.safeguard import obfuscate_ckpt, load_obf_params_into_net
 from mindspore._check_jit_forbidden_api import get_obj_module_and_name_info, is_jit_forbidden_module, \

mindspore/_akg/akg/utils/tbe_codegen_utils.py

@@ -94,11 +94,21 @@ def build_npu_for_akg(kernel_name,
                       simple_mode=False):
     import tbe
     from tbe.tvm.tir import transform
-    from tbe.tvm.driver.cce_build_module import _count_time, generate_cce_code
+    from tbe.tvm.driver.cce_build_module import _count_time
     from tbe.common.buildcfg import set_current_build_config
     from tbe.common.buildcfg.buildcfg_mapping import dynamic_shape, disable_vectorize, tik, enable_const_fold, \
         dynamic_tik, instrument_bound_checkers, tbe_workspace_size_list_length
-    
+    # try to find generate_cce_code function, since it may have different name in different tbe.
+    import importlib
+    cce_build_module = importlib.import_module("tbe.tvm.driver.cce_build_module")
+    generate_cce_code_function = None
+    generate_cce_code_function_name = {"_generate_cce_code","generate_cce_code"}
+    for func_name in generate_cce_code_function_name:
+        if hasattr(cce_build_module, func_name):
+            generate_cce_code_function = getattr(cce_build_module, func_name)
+    if generate_cce_code_function is None:
+       raise ValueError("Can not find generate cce code function.")
+
     set_current_build_config(tbe_workspace_size_list_length,
                              tbe.tvm.runtime.cce_runtime.tbe_workspace_size_list_length())
 
@@ -167,7 +177,7 @@ def build_npu_for_akg(kernel_name,
 
     _count_time(mod)
     mod = transform.SplitCoreCode()(mod)
-    generate_cce_code(mod, "cce", None)
+    generate_cce_code_function(mod, "cce", None)
 
 
 def build_tbe_codegen(kernel_name, stmt_json, arg_json, attr, ascend_type=None):

mindspore/_checkparam.py

@@ -18,6 +18,7 @@ from __future__ import absolute_import
 import re
 import inspect
 import math
+from types import FunctionType, MethodType
 from functools import reduce, wraps
 from itertools import repeat
 from collections.abc import Iterable
@@ -1375,4 +1376,23 @@ def args_type_check(*type_args, **type_kwargs):
     return type_check
 
 
+def check_hook_fn(hook_type, hook_fn):
+    """Check hook fn"""
+    if context.get_context("mode") != context.PYNATIVE_MODE:
+        logger.warning(f"'{hook_type}' function is only supported in pynative mode, you can use "
+                       f"context.set_context to set pynative mode.")
+        return False
+
+    if not isinstance(hook_fn, (FunctionType, MethodType)):
+        raise TypeError(f"When using 'hook_type(hook_fn)', the type of 'hook_fn' must be python "
+                        f"function, but got {type(hook_fn)}.")
+
+    if hook_fn.__code__.co_name == "staging_specialize":
+        raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@jit' is not supported.")
+
+    if hook_type == "register_hook" and hook_fn.__code__.co_argcount != 1:
+        raise TypeError(f"Tensor hook function {hook_fn.__name__} arg num is not equal to 1.")
+
+    return True
+
 _set_record = {}

mindspore/_extends/parse/parser.py

@@ -486,7 +486,7 @@ def convert_class_to_function(cls_str, cls_obj):
                          f"supported in 'construct' or @jit decorated function. Try to create {cls_str} "
                          f"instances external such as initialized in the method '__init__' before assigning. "
                          f"For more details, please refer to "
-                         f"https://www.mindspore.cn/docs/zh-CN/r2.3.q1/design/dynamic_graph_and_static_graph.html \n")
+                         f"https://www.mindspore.cn/docs/zh-CN/master/design/dynamic_graph_and_static_graph.html \n")
     return convert_class_to_function_map.get(cls_str)
 
 

mindspore/_extends/parse/standard_method.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.
@@ -101,7 +101,7 @@ def ndimension(x):
     return len(x.shape)
 
 
-def prod(input, axis=None, keep_dims=False):
+def prod(input, axis=None, keep_dims=False, dtype=None):
     """
     Reduces a dimension of a tensor by product all elements in the dimension.
 
@@ -110,6 +110,7 @@ def prod(input, axis=None, keep_dims=False):
         axis (Union[None, int, tuple(int), list(int)]): Dimensions of reduction,
             when axis is None or empty tuple, reduce all dimensions. Default: ``None``.
         keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
+        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
 
     Returns:
         Tensor, has the same data type as input tensor.
@@ -125,7 +126,7 @@ def prod(input, axis=None, keep_dims=False):
         >>> print(output)
         6.0
     """
-    return F.prod(input, axis, keep_dims)
+    return F.prod(input, axis, keep_dims, dtype)
 
 
 def addcdiv(input, tensor1, tensor2, value=1):
@@ -2421,11 +2422,11 @@ def float_func(*data):
             tensor_shape = F.shape(data)
             tensor_shape_len = len(tensor_shape)
             if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
-                data = F.cast(data, mstype.float64)
+                data = F.cast(data, mstype.float32)
                 return TensorToScalar()(data)
             raise ValueError(f"Can not convert Tensor with more than one element to Scalar, "
                              f"while the data's shape is: {tensor_shape}")
-        return F.scalar_cast(data, mstype.float64)
+        return F.scalar_cast(data, mstype.float32)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "float() does not support sparse tensor input.")

mindspore/amp.py

@@ -132,7 +132,7 @@ def all_finite(inputs):
 
     Tutorial Examples:
         - `Automatic Mix Precision - Loss Scaling
-          <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
+          <https://mindspore.cn/tutorials/en/master/advanced/mixed_precision.html#loss-scaling>`_
     """
     inputs = mutable(inputs)
     _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
@@ -148,7 +148,7 @@ class LossScaler(ABC):
     to scale and unscale the loss value and gradients to avoid overflow, `adjust` is used to update the
     loss scale value.
 
-    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/
+    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/master/advanced/
     mixed_precision.html#loss-scaling>`_.
 
     .. warning::
@@ -340,7 +340,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/master/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_scale_map(self.scale_value, inputs)
@@ -357,7 +357,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/master/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_unscale_map(self.scale_value, inputs)
@@ -371,7 +371,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/master/advanced/mixed_precision.html#loss-scaling>`_
         """
         one = ops.ones((), self.scale_value.dtype)
         scale_mul_factor = self.scale_value * self.scale_factor

mindspore/boost/boost_cell_wrapper.py

@@ -136,7 +136,7 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         >>> from mindspore import boost
         >>> from mindspore import nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)

mindspore/boost/group_loss_scale_manager.py

@@ -94,7 +94,7 @@ class GroupLossScaleManager(Cell):
         ...                        loss_scale_manager=loss_scale_manager,
         ...                        boost_level="O1", boost_config_dict=boost_config_dict)
         >>> # Create the dataset taking MNIST as an example. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/mnist.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/mnist.py
         >>> dataset = create_dataset()
         >>> model.train(2, dataset)
     """

mindspore/common/__init__.py

@@ -21,7 +21,7 @@ from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc,
     float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
     uint, number, tensor_type, string, type_none, TensorType, Int, \
     complex64, complex128, dtype_to_nptype, _null, _NullType, \
-    dtype_to_pytype, pytype_to_dtype, get_py_obj_dtype, QuantDtype
+    dtype_to_pytype, pytype_to_dtype, get_py_obj_dtype, QuantDtype, qint4x2
 from mindspore.common.dump import set_dump
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.seed import set_seed, get_seed
@@ -32,6 +32,7 @@ from mindspore.common.jit_config import JitConfig
 from mindspore.common.lazy_inline import lazy_inline
 from mindspore.common.mindir_util import load_mindir, save_mindir
 from mindspore.common.symbol import Symbol
+from mindspore.common.recompute import recompute
 
 # symbols from dtype
 __all__ = [
@@ -58,7 +59,7 @@ __all__ = [
     # __method__ from dtype
     "dtype_to_nptype", "dtype_to_pytype",
     "pytype_to_dtype", "get_py_obj_dtype",
-    "bfloat16",
+    "bfloat16", "qint4x2"
 ]
 
 __all__.extend([
@@ -72,4 +73,5 @@ __all__.extend([
     "mutable", "JitConfig",
     "lazy_inline", "load_mindir", "save_mindir",
     "Symbol",
+    "recompute"
 ])

mindspore/common/_register_for_recompute.py

@@ -0,0 +1,48 @@
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Registry the relation."""
+
+from __future__ import absolute_import
+from types import FunctionType
+
+
+class RecomputeRegistry:
+    """Registry class for register recompute generator."""
+
+    def __init__(self):
+        self.recompute_generator = None
+
+    def register(self, fn):
+        """
+        Register recompute generator function
+        :param fn:
+        :return:
+        """
+        if not isinstance(fn, FunctionType):
+            raise TypeError("Fn should be function type, but got", type(fn))
+        self.recompute_generator = fn
+
+    def get(self):
+        """
+        Get recompute generator.
+        :return:
+        """
+        if self.recompute_generator is None:
+            raise TypeError("Recompute generator should be initialised before get()!")
+        return self.recompute_generator
+
+
+recompute_registry = RecomputeRegistry()

mindspore/common/_stub_tensor.py

@@ -151,6 +151,7 @@ class StubTensor:
     flush_from_cache = _stub_method(Tensor.flush_from_cache)
     contiguous = _stub_method(Tensor.contiguous)
     is_contiguous = _stub_method(Tensor.is_contiguous)
+    register_hook = _stub_method(Tensor.register_hook)
 
     def stub_sync(self):
         """sync real tensor."""

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.
@@ -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.
@@ -292,6 +293,28 @@ def _handle_arg(obj, arg, compile_arg):
     return None
 
 
+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 = []
@@ -308,6 +331,22 @@ def _get_args_for_run(obj, args, kwargs, compile_args):
     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, 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_predict(obj, value, None)
+        if new_value is not None:
+            new_args.append(new_value)
+
+    return new_args
+
+
 class _MindsporeFunctionExecutor:
     """
     Represents a function compiled by graph compiler.
@@ -625,8 +664,8 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
         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/r2.3.q1/note/static_graph_syntax_support.html>`_ : MindSpore GRAPH_MODE.
-            - `PIJit <https://www.mindspore.cn/docs/en/r2.3.q1/design/dynamic_graph_and_static_graph.html>`_ : MindSpore PYNATIVE_MODE.
+            - `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`.
@@ -1382,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.
@@ -1533,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):
@@ -1566,7 +1616,9 @@ class _CellGraphExecutor:
         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):

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,7 +141,8 @@ number_type = (int8,
                float64,
                bfloat16,
                complex64,
-               complex128,)
+               complex128,
+               qint4x2,)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
@@ -349,7 +351,7 @@ 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.3.q1/mindspore/python/mindspore/common/dtype.py>`_ ,
+    `dtype.py <https://gitee.com/mindspore/mindspore/blob/master/mindspore/python/mindspore/common/dtype.py>`_ ,
     use command below to import:
 
     .. code-block::

mindspore/common/dump.py

@@ -27,7 +27,7 @@ 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.3.q1/debug/dump.html>`_ for details.
+    <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.
 
@@ -61,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.3.q1/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.3.q1/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:

mindspore/common/jit_config.py

@@ -42,7 +42,7 @@ class JitConfig:
             The value must be ``"STRICT"`` , ``"LAX"`` or ``""`` . Default to an empty string, which means that this
             JitConfig configuration will be ignored and the jit_syntax_level of ms.context will be used.
             For more details about ms.context, refer to
-            `set_context <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/mindspore/mindspore.set_context.html>`_ .
+            `set_context <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html>`_ .
             Default: ``""`` .
 
             - ``"STRICT"``: Only basic syntax is supported, and execution performance is optimal. Can be used for MindIR
@@ -58,6 +58,13 @@ class JitConfig:
               compiling performance.
             - ``DEBUG``: Used for debugging when errors occur, more information will be record in compiling process.
 
+        infer_boost (str, optional): enable infer boost mode.
+            The value must be ``"on"`` , ``"off"``. Default to an "off", which means that disable infer boost.
+            when infer boost mode is enabled, MindSpore will use high perf kernel lib, use faster runtime make
+            infer speed is best.
+            Note: current infer boost only support `jit_level` == ``"O0"`` and only Atlas A2 series products
+            are supported.
+
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
     Examples:
@@ -66,22 +73,26 @@ class JitConfig:
         >>> jitconfig = JitConfig(jit_level="O1")
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>>
         >>> net.set_jit_config(jitconfig)
     """
-    def __init__(self, jit_level="", exc_mode="auto", jit_syntax_level="", debug_level="RELEASE", **kwargs):
+    def __init__(self, jit_level="", exc_mode="auto", jit_syntax_level="", debug_level="RELEASE",
+                 infer_boost="off", **kwargs):
         if jit_level not in ["", "O0", "O1", "O2"]:
             raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
-        if exc_mode not in ['auto', 'sink', 'no_sink']:
+        if exc_mode not in ["auto", "sink", "no_sink"]:
             raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
-        if jit_syntax_level != "" and jit_syntax_level not in ['STRICT', 'COMPATIBLE', 'LAX']:
+        if jit_syntax_level != "" and jit_syntax_level not in ["STRICT", "COMPATIBLE", "LAX"]:
             raise ValueError("For 'jit_syntax_level' must be one of '['STRICT', 'LAX']'.")
-        if debug_level not in ['RELEASE', 'DEBUG']:
+        if debug_level not in ["RELEASE", "DEBUG"]:
             raise ValueError("For 'debug_level' must be one of '['RELEASE', 'DEBUG']'.")
+        if infer_boost != "" and infer_boost not in ["on", "off"]:
+            raise ValueError("For 'infer_boost' must be one of '['on', 'off']'.")
         self.jit_config_dict = kwargs
         self.jit_config_dict["jit_level"] = jit_level
         self.jit_config_dict["exc_mode"] = exc_mode
         self.jit_config_dict["jit_syntax_level"] = jit_syntax_level
         self.jit_config_dict["debug_level"] = debug_level
+        self.jit_config_dict["infer_boost"] = infer_boost

mindspore/common/parameter.py

@@ -336,6 +336,8 @@ class Parameter(Tensor_):
                     cpu_cast = Cast().set_device("CPU")
                     data = cpu_cast(data, mstype.float32)
                     return (Tensor, data.asnumpy(), mstype.bfloat16)
+                if data.dtype == mstype.qint4x2:
+                    return (Tensor, data.asnumpy(), mstype.qint4x2)
                 return (Tensor, data.asnumpy())
 
             not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()) or _is_in_parallel_mode()
@@ -364,7 +366,7 @@ class Parameter(Tensor_):
 
         Tutorial Examples:
             - `Parameter Server Mode
-              <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/parameter_server_training.html>`_
+              <https://www.mindspore.cn/tutorials/experts/en/master/parallel/parameter_server_training.html>`_
         """
         if not _is_ps_mode() or not (_is_role_worker() or _is_role_pserver() or _is_role_sched()):
             raise RuntimeError("Must complete following two steps before calling set_param_ps: \n"
@@ -792,6 +794,9 @@ class Parameter(Tensor_):
         """
         Add a pipeline stage to the parameter.
 
+        Note:
+            This interface is deprecated in 2.3, and will be deleted in the future.
+
         Args:
             stage(int): The pipeline stage to be added.
 
@@ -1023,7 +1028,7 @@ class ParameterTuple(tuple):
 
         Tutorial Examples:
             - `Cell and Parameter - Parameter Tuple
-              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/modules/layer.html#parameter-tuple>`_
+              <https://mindspore.cn/tutorials/en/master/advanced/modules/layer.html#parameter-tuple>`_
         """
         Validator.check_str_by_regular(prefix)
         new = []