mindspore 2.4.1__cp311-cp311-win_amd64.whl → 2.5.0__cp311-cp311-win_amd64.whl

mindspore/common/parameter.py

@@ -17,13 +17,14 @@
 from __future__ import absolute_import
 
 from copy import copy
+
 import time
 import os
 import sys
 import math
 import numbers
-from contextlib import contextmanager
 import numpy as np
+
 from mindspore import log as logger
 from mindspore.log import _LogActionOnce
 from mindspore._c_expression import ParamInfo
@@ -54,15 +55,15 @@ 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
 
-@contextmanager
-def no_init_parameters():
-    init_class = globals()["Parameter"]
-    setattr(init_class, "init_param", False)
-    try:
-        yield
-    finally:
-        setattr(init_class, "init_param", True)
+def parameter_hook_updated():
+    global _parameter_hook_updated
+    return _parameter_hook_updated
 
 
 def _is_in_auto_parallel_mode():
@@ -216,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: ``""`` .
@@ -224,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:
@@ -262,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:
@@ -303,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)):
@@ -467,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_)
@@ -692,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
@@ -857,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):
@@ -913,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)
@@ -988,9 +982,7 @@ class Parameter(Tensor_):
         """
         if self.is_default_input_init and self.is_in_parallel != _is_in_auto_parallel_mode():
             raise RuntimeError("Must set or change parallel mode before any initializer Tensor created.")
-        if hasattr(self, "init_param") and self.init_param:
-            return self
-        if self.init_mode is None:
+        if self.init_mode is None or not self.has_init:
             return self
         if self.inited_param is not None:
             return self.inited_param
@@ -1016,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):
     """