mindspore 2.4.10__cp311-cp311-manylinux1_x86_64.whl → 2.5.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/common/api.py

@@ -41,19 +41,19 @@ from mindspore.common.sparse_tensor import RowTensor as PythonRowTensor
 from mindspore._c_expression.amp import get_curr_amp_strategy
 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, StubNode
 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, _is_parallel_mode
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import is_stub_tensor
 from mindspore.common._utils import is_shape_unknown
-from mindspore.common.mutable import mutable
+from mindspore.common.mutable import mutable, _check_element_type
 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
 from mindspore.common._pijit_context import PIJitCaptureContext
-from mindspore.common.parameter import Parameter
+from mindspore.common.parameter import Parameter, set_parameter_hook_updated, parameter_hook_updated
 
 # Store ms_function class compiled pipeline cache.
 ms_compile_cache = set()
@@ -150,6 +150,8 @@ 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, StubNode):
+        return ms.common._stub_tensor._convert_stub(data)
     if data.__class__ is tuple:
         # Handle namedtuple since its type is tuple.
         if hasattr(data, "_fields"):
@@ -273,7 +275,9 @@ def __get_compile_cache_dep_files(file_path, compile_cache_dep_files, pkg):
             else:
                 whole_module = module_name
                 if n.name is not None:
-                    whole_module += "." + n.name
+                    if not whole_module.endswith("."):
+                        whole_module += "."
+                    whole_module += n.name
             try:
                 module_spec = importlib.util.find_spec(whole_module, pkg)
             except (ModuleNotFoundError, ValueError):
@@ -305,7 +309,22 @@ def _get_compile_cache_dep_files():
     return compile_cache_dep_files
 
 
-def _restore_mutable_attr(args_list, compile_args):
+def _contains_auto_grad_tensor(obj):
+    """Check object is or contains auto grad tensor element"""
+    if isinstance(obj, PythonTensor):
+        return obj._has_auto_grad()
+    if isinstance(obj, (tuple, list)):
+        for element in obj:
+            if _contains_auto_grad_tensor(element):
+                return True
+    if isinstance(obj, dict):
+        for key in obj:
+            if _contains_auto_grad_tensor(obj[key]):
+                return True
+    return False
+
+
+def _add_mutable_attr(args_list, compile_args, is_grad):
     """Restore the mutable attr for every arg."""
     new_compile_args = ()
     for idx, arg in enumerate(args_list):
@@ -316,7 +335,12 @@ def _restore_mutable_attr(args_list, compile_args):
             else:
                 new_compile_args += (mutable(compile_args[idx], False),)
         else:
-            new_compile_args += (compile_args[idx],)
+            if is_grad and _contains_auto_grad_tensor(arg):
+                if not _check_element_type(arg):
+                    raise RuntimeError("Input \"%s\" contains tensor with gradient but can not mutable." % (str(arg)))
+                new_compile_args += (mutable(compile_args[idx], False),)
+            else:
+                new_compile_args += (compile_args[idx],)
     return new_compile_args
 
 
@@ -330,6 +354,7 @@ def _get_parameter_layout():
 
 def _handle_arg(obj, arg, compile_arg):
     """Handle arg for runtime .If need handle the arg, return True"""
+    from mindspore._extends.parse import compile_config
     if isinstance(arg, PythonTensor):
         if arg.has_init:
             arg.init_data()
@@ -342,7 +367,8 @@ def _handle_arg(obj, arg, compile_arg):
         if isinstance(arg, list) and not arg:
             return None
         return arg
-    elif context.get_context("grad_for_scalar") and isinstance(arg, (int, float)):
+    elif (context.get_context("grad_for_scalar") or str(compile_config.GRAD_FOR_SCALAR) == '1') and \
+            isinstance(arg, (int, float)):
         return arg
     elif hasattr(obj, "enable_tuple_broaden") and obj.enable_tuple_broaden and isinstance(arg, tuple) and \
             _check_all_tensor(arg):
@@ -528,6 +554,29 @@ def _get_parameter_ids(args, kwargs):
             parameter_ids += str(id(value))
     return parameter_ids
 
+def _get_tensor_hook_key(tensor):
+    """Get the hook key of Tensor/Parameter"""
+    return ".".join(map(str, map(id, tensor.hooks())))
+
+def _get_hook_key(*args, **kwargs):
+    """Get the hook key of Tensors/Parameters"""
+    hook_key = ""
+    for idx, arg in enumerate(args):
+        if idx != 0:
+            hook_key += "."
+        # Only arg of the type Tensor or Parameter is supported now
+        if isinstance(arg, (Tensor, Parameter)):
+            hook_key += _get_tensor_hook_key(arg)
+
+    for idx, value in enumerate(kwargs.values()):
+        if idx != 0:
+            hook_key += "."
+        # Only kwarg of the type Tensor or Parameter is supported now
+        if isinstance(value, (Tensor, Parameter)):
+            hook_key += _get_tensor_hook_key(value)
+
+    return hook_key
+
 
 class _MindsporeFunctionExecutor:
     """
@@ -581,13 +630,14 @@ class _MindsporeFunctionExecutor:
             _pynative_executor.clear_res()
             raise err
 
-        if context.get_context("precompile_only"):
+        if context.get_context("precompile_only") or os.getenv('MS_DEV_PRECOMPILE_ONLY') == '1':
             return None
 
         new_inputs = self._generate_run_args(args_list, kwargs)
-        output = self._graph_executor(tuple(new_inputs), phase)
         if context.get_context("mode") == context.PYNATIVE_MODE:
-            output = _pynative_executor.grad_jit(output, *new_inputs)
+            output = _pynative_executor.grad_jit(*new_inputs)
+        else:
+            output = self._graph_executor(tuple(new_inputs), phase)
 
         return output
 
@@ -605,8 +655,10 @@ class _MindsporeFunctionExecutor:
         compile_args = get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id,
                                                                               self.input_signature)
 
-        # Restore the mutable attr for every arg.
-        compile_args = _restore_mutable_attr(args, compile_args)
+        # Add mutable for compile_args for two scene:
+        # 1) Origin args is mutable.
+        # 2) Args contains sequence with gradient tensor.
+        compile_args = _add_mutable_attr(args, compile_args, _pynative_executor.requires_grad())
         self._compile_args = compile_args
         generate_name, echo_function_name = self._get_generate_name()
         # The full Function name
@@ -645,11 +697,14 @@ class _MindsporeFunctionExecutor:
         parameter_ids = _get_parameter_ids(args, kwargs)
         if parameter_ids != "":
             key = str(key) + '.' + parameter_ids
+
+        key = str(key) + "." + _get_hook_key(*args, **kwargs)
+
         phase = generate_name + '.' + str(key)
 
         update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, self.input_signature)
 
-        if phase in ms_compile_cache:
+        if phase in ms_compile_cache and not parameter_hook_updated():
             # 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()
@@ -683,6 +738,7 @@ class _MindsporeFunctionExecutor:
 
         if not is_compile:
             raise RuntimeError("Executor compile failed.")
+        set_parameter_hook_updated(False)
         ms_compile_cache.add(phase)
 
         return phase
@@ -1351,8 +1407,6 @@ class _no_grad(contextlib.ContextDecorator):
         self.prev_state = False
 
     def __enter__(self):
-        if context.get_context("mode") == context.GRAPH_MODE:
-            raise RuntimeError("For no_grad feature, currently only support Pynative mode, but got Graph mode.")
         self.prev_state = _pynative_executor.enable_grad()
         _pynative_executor.set_enable_grad(False)
 
@@ -1501,18 +1555,18 @@ class _PyNativeExecutor:
         """
         self._executor.sync()
 
-    def grad_jit(self, output, *args):
+    def grad_jit(self, *args):
         """
         Building grad graph decorated by jit.
 
         Args:
-            output (tuple): The function or cell decorated by jit output object.
             args (tuple): Function or cell decorated by jit input arguments.
 
         Return:
-            None.
+            output: The output object of function or cell decorated by jit.
         """
-        return self._executor.grad_jit(output, *args)
+        output = self._executor.grad_jit(*args)
+        return output
 
     def call_custom_bprop(self, obj, output, *args, **kwargs):
         """
@@ -1803,8 +1857,12 @@ class _CellGraphExecutor:
             self.enable_tuple_broaden = obj.enable_tuple_broaden
         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)
+
+        obj.arguments_key = obj.arguments_key + "." + _get_hook_key(*args, **kwargs)
+
         # When exist parameter in the top graph inputs, need check if the parameter object has changed.
         parameter_ids = _get_parameter_ids(args, kwargs)
         if parameter_ids != "":
@@ -1814,7 +1872,7 @@ class _CellGraphExecutor:
         obj.phase_cache[raw_phase] = phase
         update_auto_dynamic_shape_phase(args, key_id, phase)
         obj.current_phase = phase
-        if phase in obj.compile_cache and self.has_compiled(phase):
+        if phase in obj.compile_cache and self.has_compiled(phase) and not parameter_hook_updated():
             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.
@@ -1840,6 +1898,7 @@ class _CellGraphExecutor:
         obj.compile_cache.add(phase)
         if not result:
             raise RuntimeError("Executor compile failed.")
+        set_parameter_hook_updated(False)
         graph = self._graph_executor.get_func_graph(phase)
 
         if graph is None:
@@ -1875,7 +1934,7 @@ class _CellGraphExecutor:
         return self._graph_executor.get_allreduce_fusion(real_phase)
 
     def __call__(self, obj, *args, phase='predict'):
-        if context.get_context("precompile_only") or _is_role_sched():
+        if context.get_context("precompile_only") or os.getenv('MS_DEV_PRECOMPILE_ONLY') == '1' or _is_role_sched():
             return None
         return self.run(obj, *args, phase=phase)
 
@@ -2012,6 +2071,24 @@ def ms_memory_recycle():
     _ms_memory_recycle()
 
 
+def set_recursion_limit(recursion_limit=1000):
+    """
+    Specify the recursion depth limit of function call before compiling graph.
+    It needs to be call when the nested function call is too deep or the number of sub graphs is too large.
+    If recursion_limit is set larger than before, the system max stack depth should be set larger too,
+    otherwise a `core dumped` exception may be raised because of system stack overflow.
+
+    Args:
+        recursion_limit (int, optional): The recursion depth limit. Must be a positive integer. Default: ``1000`` .
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_recursion_limit(10000)
+    """
+    recursion_limit = Validator.check_positive_int(recursion_limit)
+    GraphExecutor_.get_instance().set_max_call_depth(recursion_limit)
+
+
 def _generate_branch_control_input(obf_random_seed):
     """Generate append network input for dynamic obfuscation in random seed mode."""
     seed_max = 2 ** 32 - 1

mindspore/common/dtype.py

@@ -59,58 +59,58 @@ __all__.extend(__dtype__)
 __all__.extend(__method__)
 
 # type definition
-bool_ = typing.Bool()
+bool_ = typing.kBool
 
-qint4x2 = typing.Int(4)
-int8 = typing.Int(8)
+qint4x2 = typing.kInt4
+int8 = typing.kInt8
 byte = int8
-int16 = typing.Int(16)
+int16 = typing.kInt16
 short = int16
-int32 = typing.Int(32)
+int32 = typing.kInt32
 intc = int32
-int64 = typing.Int(64)
+int64 = typing.kInt64
 intp = int64
 
-uint8 = typing.UInt(8)
+uint8 = typing.kUInt8
 ubyte = uint8
-uint16 = typing.UInt(16)
+uint16 = typing.kUInt16
 ushort = uint16
-uint32 = typing.UInt(32)
+uint32 = typing.kUInt32
 uintc = uint32
-uint64 = typing.UInt(64)
+uint64 = typing.kUInt64
 uintp = uint64
 
-float16 = typing.Float(16)
+float16 = typing.kFloat16
 half = float16
-float32 = typing.Float(32)
+float32 = typing.kFloat32
 single = float32
-float64 = typing.Float(64)
+float64 = typing.kFloat64
 double = float64
-bfloat16 = typing.BFloat(16)
-complex64 = typing.Complex(64)
-complex128 = typing.Complex(128)
-
-number = typing.Number()
-int_ = typing.Int()
-uint = typing.UInt()
-float_ = typing.Float()
-string = typing.String()
-list_ = typing.List()
-tuple_ = typing.Tuple()
-type_none = typing.TypeNone()
-_null = typing.TypeNull()
-
-tensor_type = typing.TensorType()
-index_slices = typing.RowTensorType()
-coo_tensor = typing.COOTensorType()
-csr_tensor = typing.CSRTensorType()
+bfloat16 = typing.kBFloat16
+complex64 = typing.kComplex64
+complex128 = typing.kComplex128
+
+number = typing.kNumber
+int_ = typing.kInt
+uint = typing.kUInt
+float_ = typing.kFloat
+string = typing.kString
+list_ = typing.kList
+tuple_ = typing.kTuple
+type_none = typing.kTypeNone
+_null = typing.kTypeNull
+
+tensor_type = typing.kTensorType
+index_slices = typing.kRowTensorType
+coo_tensor = typing.kCOOTensorType
+csr_tensor = typing.kCSRTensorType
 undetermined = typing.UndeterminedType()
 
 function = typing.Function()
 symbolic_key = typing.SymbolicKeyType()
-env_type = typing.EnvType()
-type_type = typing.TypeType()
-type_refkey = typing.RefKeyType()
+env_type = typing.kTypeEnv
+type_type = typing.kTypeType
+type_refkey = typing.kRefKeyType
 
 Int = typing.Int
 Float = typing.Float

mindspore/common/dump.py

@@ -64,7 +64,8 @@ def set_dump(target, enabled=True):
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, set_dump
         >>>
-        >>> ms.set_context(device_target="Ascend", mode=ms.GRAPH_MODE)
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="Ascend")
         >>>
         >>> class MyNet(nn.Cell):
         ...     def __init__(self):

mindspore/common/file_system.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """File system registration management"""
+from mindspore import log as logger
 
 
 class FileSystem:
@@ -22,7 +23,6 @@ class FileSystem:
         self.create_args = ("ab",)
         self.open = open
         self.open_args = ("rb",)
-        self.backend = "basic"
 
 
 def _register_basic_file_system(fs: FileSystem):
@@ -40,11 +40,16 @@ def _register_mindio_file_system(fs: FileSystem):
         import mindio
     except ImportError:
         return False
-    if mindio.initialize() != 0:
+    try:
+        ret = mindio.initialize()
+    except AttributeError as e:
+        logger.warning(f"Failed to initialize MindIO: {e}")
+        return False
+    if ret != 0:
+        logger.warning(f"Failed to initialize MindIO: ret = {ret}")
         return False
     fs.create = mindio.create_file
     fs.create_args = ()
     fs.open = mindio.open_file
     fs.open_args = ()
-    fs.backend = "mindio"
     return True

mindspore/common/generator.py

@@ -80,6 +80,7 @@ class Generator:
             Tensor(0, mstype.int64), name="offset", requires_grad=False)
 
         self._generator = GeneratorOp().set_device("CPU")
+        self._generator.add_prim_attr("manual_seed", False)
         self._to_scalar = TensorToScalar()
 
     def set_state(self, state):
@@ -125,6 +126,7 @@ class Generator:
             raise TypeError("Seed must be an integer.")
         seed = Tensor(seed, mstype.int64)
         self._generator(MANUAL_SEED, (self._seed, self._offset, seed))
+        self._generator.add_prim_attr("manual_seed", True)
         return self
 
     def initial_seed(self):

mindspore/common/hook_handle.py

@@ -29,8 +29,9 @@ class _TensorHookHandle:
         ``Ascend`` ``GPU`` ``CPU``
     """
 
-    def __init__(self):
+    def __init__(self, tensor):
         self.id = None
+        self.tensor = tensor
 
     def remove(self):
         """
@@ -66,6 +67,7 @@ class _TensorHookHandle:
         """
         if self.id is not None:
             Tensor_.remove_hook(self.id)
+            self.tensor._remove_hook() # pylint:disable=protected-access
 
 
 class HookHandle:

mindspore/common/initializer.py

@@ -36,9 +36,7 @@ class Initializer:
     Note:
         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/master/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
-        mindspore-tensor-init-data>`_ .
+        followed in most of the cases. For more information, please refer to :func:`mindspore.Tensor.init_data` .
 
     Args:
         kwargs (dict): Keyword arguments for Initializer.
@@ -841,7 +839,8 @@ def initializer(init, shape=None, dtype=mstype.float32):
         dtype (:class:`mindspore.dtype`): The type of data in initialized tensor. Default: ``mstype.float32`` .
 
     Returns:
-        Tensor, return is Tensor object.
+        Returns a Tensor with the shape specified by the input `shape`. If `shape` is ``None``,
+        the returned Tensor will have the same shape as ``init``.
 
     Raises:
         TypeError: The type of the argument 'init' is not correct.

mindspore/common/lazy_inline.py

@@ -27,6 +27,10 @@ def lazy_inline(fn=None, attrs=None, policy=None):
     Registering the decorator of the built-in function `__init__` of a cell, the decorator
     will add the parameters of `__init__` according to the `attrs` as the attributes of this cell.
 
+    For a detailed description of the function, see `Using the lazy_inline decorator
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph_syntax/
+    static_graph_expert_programming.html#using-lazy-inline-decorator>`_ .
+
     .. warning::
         This feature is only supported on Ascend and is not supported on other hardwares.
         The construct parameters must be positional or key word arguments and have not default values.
@@ -47,6 +51,7 @@ def lazy_inline(fn=None, attrs=None, policy=None):
         ``Ascend``
 
     Examples:
+        >>> import os
         >>> import numpy as np
         >>> from mindspore import Tensor
         >>> import mindspore.nn as nn
@@ -154,8 +159,9 @@ def lazy_inline(fn=None, attrs=None, policy=None):
         ...     inp = Tensor(np.ones([1, 3, 224, 224]).astype(np.float32))
         ...     net(inp)
         ...
-        >>> context.set_context(mode=context.GRAPH_MODE,
-        ...                     save_graphs=True, save_graphs_path="./lazy")
+        >>> context.set_context(mode=context.GRAPH_MODE)
+        >>> os.environ["MS_DEV_SAVE_GRAPHS"] = "2"
+        >>> os.environ["MS_DEV_SAVE_GRAPHS_PATH"] = os.path.realpath("./lazy")
         ...
         >>> test_compile()
     """

mindspore/common/mindir_util.py

@@ -26,6 +26,9 @@ def load_mindir(file_name):
     """
     load protobuf file.
 
+    Note:
+        The interface is deprecated from version 2.5 and will be removed in a future version.
+
     Args:
         file_name (str): File name.
 
@@ -42,7 +45,8 @@ def load_mindir(file_name):
         >>> import mindspore as ms
         >>> md = ms.load_mindir("test.mindir")
     """
-
+    logger.warning("The interface 'mindspore.load_mindir' is deprecated from version 2.5 "
+                   "and will be removed in a future version.")
     Validator.check_file_name_by_regular(file_name)
     file_name = os.path.realpath(file_name)
     model = mindir_model()
@@ -65,6 +69,9 @@ def save_mindir(model, file_name):
     """
     save protobuf file.
 
+    Note:
+        The interface is deprecated from version 2.5 and will be removed in a future version.
+
     Args:
         model (ModelProto): mindir model
         file_name (str): File name.
@@ -84,7 +91,8 @@ def save_mindir(model, file_name):
         >>> md_new = ms.load_mindir("test_new.mindir")
         >>> md_new.user_info
     """
-
+    logger.warning("The interface 'mindspore.save_mindir' is deprecated from version 2.5 "
+                   "and will be removed in a future version.")
     Validator.check_file_name_by_regular(file_name)
     file_name = os.path.realpath(file_name)
     if not file_name.endswith('.mindir'):

mindspore/common/parameter.py

@@ -17,12 +17,14 @@
 from __future__ import absolute_import
 
 from copy import copy
+
 import time
 import os
 import sys
 import math
 import numbers
 import numpy as np
+
 from mindspore import log as logger
 from mindspore.log import _LogActionOnce
 from mindspore._c_expression import ParamInfo
@@ -53,6 +55,16 @@ PARAMETER_NAME_PREFIX_MAX_LEN = 1024
 # 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
+
 
 def _is_in_auto_parallel_mode():
     """Get parallel mode."""
@@ -205,7 +217,7 @@ class Parameter(Tensor_):
             broadcast and gradients communication would not be applied to the `Parameter`. Default: ``False`` .
         parallel_optimizer (bool): It is used to filter the weight shard operation in `SEMI_AUTO_PARALLEL` or
             `AUTO_PARALLEL` mode. It works only when enable parallel optimizer in
-            `mindspore.set_auto_parallel_context()`. Default: ``True`` .
+            :func:`mindspore.set_auto_parallel_context`. Default: ``True`` .
         storage_format (str): Only Ascend device target is supported. It is used to specify the format of the weight
             loaded to the device. By default, the format is not changed. The optional values are ``"FRACTAL_NZ"`` ,
             ``"NC1HWC0"`` , ``"FRACTAL_Z"`` , etc. Default: ``""`` .
@@ -213,7 +225,8 @@ class Parameter(Tensor_):
             stored. By default, the parameter will be stored on NPU while computing. When the device is specified as
             ``"CPU"``, the parameter will be loaded into the device when it needs to be used, and unloaded to the CPU
             after use. It takes effext only when `memory_offload` is ``"ON"``, `jit_level` is not ``"O2"`` and
-            `memory_optimize_level` is ``O0`` in `mindspore.set_context()`. Less device memory is needed when device is
+            `memory_optimize_level` is ``O0`` in :func:`mindspore.set_context`.
+            Less device memory is needed when device is
             specified as ``"CPU"``.
 
     Examples:
@@ -251,7 +264,6 @@ class Parameter(Tensor_):
         # it's better to make the Initializer a kind of tensor.
         obj.init_mode = None
         obj.is_default_input_init = init_data_flag
-        obj.from_ckpt = False
         if obj.has_init:
             obj.init_mode = default_input
         else:
@@ -292,7 +304,6 @@ class Parameter(Tensor_):
         self.is_in_shard = False
         self._pipeline_stage_list = []
         self.slice_num = 1
-        self.from_ckpt = False
         if -1 in self.shape:
             raise ValueError(f"All shape elements of the Parameter must be positive. But got None.")
         if isinstance(default_input, (Tensor_, Tensor)):
@@ -456,10 +467,12 @@ class Parameter(Tensor_):
 
     @property
     def param_info(self):
+        Tensor_.wait_pipeline(self)
         return self._param_info
 
     @param_info.setter
     def param_info(self, param_info_):
+        Tensor_.wait_pipeline(self)
         param_info_.obj = self
         self._param_info = param_info_
         Tensor_.param_info.fset(self, param_info_)
@@ -681,7 +694,7 @@ class Parameter(Tensor_):
         Get the optimizer parallel status(bool) of the parameter.
 
         It is used to filter the weight shard operation in `AUTO_PARALLEL` and `SEMI_AUTO_PARALLEL` mode. It works only
-        when enable parallel optimizer in `mindspore.set_auto_parallel_context()`.
+        when enable parallel optimizer in :func:`mindspore.set_auto_parallel_context`.
 
         Examples:
             >>> from mindspore import Tensor, Parameter
@@ -846,16 +859,10 @@ class Parameter(Tensor_):
                         f"Use .set_dtype(xxx) to change the dtype.")
 
     @staticmethod
-    def _set_data_check_input_valid(current_shape, data_shape, current_tensor_is_init, incoming_tensor_is_init,
-                                    from_ckpt, slice_shape=False, slice_num=1):
-        if not from_ckpt and incoming_tensor_is_init and not current_tensor_is_init:
+    def _set_data_check_input_valid(current_tensor_is_init, incoming_tensor_is_init):
+        if incoming_tensor_is_init and not current_tensor_is_init:
             raise TypeError("The original tensor data is initialized, but the argument 'data' is not initialized."
                             "Please initialize 'data' before call this method.")
-        if tuple(current_shape) != tuple(data_shape):
-            # If Slice create Parameter shape can be change.
-            if not slice_shape and slice_num == 1:
-                raise ValueError(f"Can not change the shape of Parameter which has been initialized."
-                                 f" Current shape is {current_shape}, and incoming is {data_shape}.")
 
     @staticmethod
     def _from_tensor(tensor, *args, **kwargs):
@@ -902,8 +909,6 @@ class Parameter(Tensor_):
         # both not init.
         incoming_tensor_is_init = isinstance(data, Tensor) and not data.has_init
         current_tensor_is_init = isinstance(self, Tensor) and not self.has_init
-        Parameter._set_data_check_input_valid(self.shape, data.shape, current_tensor_is_init, incoming_tensor_is_init,
-                                              self.from_ckpt, slice_shape, self.slice_num)
         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)
@@ -1003,6 +1008,17 @@ class Parameter(Tensor_):
         _offload_if_config(obj)
         return obj
 
+    def register_hook(self, hook_fn):
+        """
+        For details, please refer to :func:`mindspore.Tensor.register_hook`.
+        """
+        handle = Tensor.register_hook(self, hook_fn)
+        set_parameter_hook_updated(True)
+        return handle
+
+    def _remove_hook(self):
+        set_parameter_hook_updated(True)
+
 
 class ParameterTuple(tuple):
     """