mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:a4230c71,[branch]:(HEAD->master,origin/master,origin/HEAD)''
+__commit_id__ = ''[sha1]:8c86f33f,[branch]:(HEAD->master,origin/master,origin/HEAD)''

mindspore/__init__.py

@@ -23,6 +23,7 @@ from mindspore.mindrecord import *
 from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr, reshard
 from mindspore.train import *
 from mindspore.log import *
+from mindspore.utils import *
 from mindspore.context import GRAPH_MODE, PYNATIVE_MODE, set_context, get_context, set_auto_parallel_context, \
     get_auto_parallel_context, reset_auto_parallel_context, ParallelMode, set_ps_context, \
     get_ps_context, reset_ps_context, set_offload_context, get_offload_context, STRICT, COMPATIBLE, LAX
@@ -30,7 +31,8 @@ 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, load_segmented_checkpoints
+    Layout, sync_pipeline_shared_parameters, parameter_broadcast, load_segmented_checkpoints, \
+    safetensors_to_ckpt, ckpt_to_safetensors, unified_safetensors
 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/_checkparam.py

@@ -29,7 +29,6 @@ from mindspore import log as logger
 from mindspore.common import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
 
-
 EQ = 1  # ==
 NE = 2  # !=
 LT = 3  # <
@@ -148,7 +147,7 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
             ret = (1, 1, arg_value, arg_value, arg_value) if ret_five else (arg_value, arg_value, arg_value)
         elif len(arg_value) == 3:
             ret = (1, 1, arg_value[0], arg_value[1], arg_value[2]) if ret_five else arg_value
-        else: # case: len(arg_value) == 5
+        else:  # case: len(arg_value) == 5
             ret = arg_value if ret_five else (arg_value[2], arg_value[3], arg_value[4])
 
         return ret
@@ -240,6 +239,7 @@ def check_is_number(arg_value, arg_type, arg_name=None, prim_name=None):
         else:
             raise TypeError(f"{prim_name} type of {arg_name} must be '{arg_type.__name__}', " \
                             f"but got '{type(arg_value).__name__}'.")
+
     _check_param()
     return arg_value
 
@@ -265,6 +265,7 @@ def check_number_range(arg_value, lower_limit, upper_limit, rel, value_type, arg
             rel_str = _format_str_two_value(lower_limit, upper_limit, rel)
             raise ValueError(f"{prim_name} {arg_name} must be in range of {rel_str}, " \
                              f"but got {arg_value} with type '{type(arg_value).__name__}'.")
+
     _check_param()
     return arg_value
 
@@ -274,6 +275,7 @@ def check(arg_name, arg_value, value_name, value, rel=EQ, prim_name=None, excp_c
     Method for judging relation between two int values or list/tuple made up of ints.
     This method is not suitable for judging relation between floats, since it does not consider float error.
     """
+
     def _check():
         if not _check_binary_rel(arg_value, value, rel):
             rel_str = _format_str_one_value(f'{value_name}: {value}', rel)
@@ -475,20 +477,24 @@ def check_non_negative_float(arg_value, arg_name=None, prim_name=None):
 
 def check_number(arg_name, arg_value, value, rel, prim_name):
     """Number value judgment."""
+
     def _check():
         if not _check_binary_rel(arg_value, value, rel):
             rel_str = _format_str_one_value(value, rel)
             raise ValueError(f'For \'{prim_name}\', the argument \'{arg_name}\' ' \
                              f'must {rel_str}, but got {arg_value}.')
+
     _check()
     return arg_value
 
 
 def check_isinstance(arg_name, arg_value, classes):
     """Check arg isinstance of classes"""
+
     def _check():
         if not isinstance(arg_value, classes):
             raise ValueError(f'The parameter \'{arg_name}\' must be isinstance of {classes}, but got {arg_value}.')
+
     _check()
     return arg_value
 
@@ -507,6 +513,7 @@ def check_bool(arg_value, arg_name=None, prim_name=None):
     def _check():
         if not isinstance(arg_value, bool):
             raise TypeError(f"{prim_name} {arg_name} must be a bool, but got {type(arg_value).__name__}.")
+
     _check()
     return arg_value
 
@@ -547,6 +554,7 @@ def check_string(arg_value, valid_values, arg_name=None, prim_name=None):
         if not (isinstance(arg_value, str) and arg_value in valid_values):
             raise ValueError(f"{msg_prefix} '{arg_name}' must be str and must be in '{valid_values}'," \
                              f" but got '{arg_value}'.")
+
     _check()
     return arg_value
 
@@ -626,10 +634,12 @@ def check_subclass(arg_name, type_, template_types, prim_name, addition_error_in
 
 def check_valid_input(arg_name, arg_value, prim_name):
     """Checks valid value."""
+
     def _check():
         if arg_value is None:
             raise ValueError(f"For \'{prim_name}\', the argument '{arg_name}'" \
                              f"can not be None, but got {arg_value}.")
+
     _check()
     return arg_value
 
@@ -786,6 +796,7 @@ def check_astype_dtype(dtype):
 
 def check_transpose_axis(axes, ndim):
     """Check the axis argument for tensor.transpose"""
+
     def _check_dim():
         # if multiple arguments provided, it must be `ndim` number of ints
         if len(axes) != ndim:
@@ -793,7 +804,7 @@ def check_transpose_axis(axes, ndim):
                              f"but got {len(axes)} in the number of axes.")
 
     if not axes or (len(axes) == 1 and axes[0] is None):
-        return tuple(range(ndim-1, -1, -1))
+        return tuple(range(ndim - 1, -1, -1))
 
     if len(axes) == 1:
         perm = axes[0]
@@ -912,6 +923,7 @@ def prepare_shape_for_squeeze(shape, axes):
 
 def check_axis_in_range(axis, ndim):
     """Checks axes are with the bounds of ndim"""
+
     def _check():
         if not isinstance(axis, int):
             raise TypeError(f'The axes must be integers, but got {type(axis)}')
@@ -928,6 +940,7 @@ def check_axis_valid(axes, ndim):
     Checks axes are valid given ndim, and returns axes that can be passed
     to the built-in operator (non-negative, int or tuple)
     """
+
     def _check_range(axes):
         for axis in axes:
             check_axis_in_range(axis, ndim)
@@ -977,16 +990,17 @@ def infer_out_shape(*shapes):
     """
     Returns shape of output after broadcasting. Raises ValueError if shapes cannot be broadcast.
     """
+
     def _check(items, max_size, shapes):
         for item in items:
             if item not in (1, max_size):
                 raise ValueError(f'For Tensor, the dimension on each axis must be 1 or the max value on the axis' \
                                  f'to support broadcasting, but got shapes {shapes,}')
+
     shape_out = ()
     max_len = max([len(it) for it in shapes])
     for i in range(max_len):
-        items = [it[i-(max_len-len(it))] if i - (max_len - len(it))
-                 >= 0 else 1 for it in shapes]
+        items = [it[i - (max_len - len(it))] if i - (max_len - len(it)) >= 0 else 1 for it in shapes]
         max_size = 0 if 0 in items else max(items)
         _check(items, max_size, shapes)
         shape_out = shape_out + (max_size,)
@@ -1015,6 +1029,7 @@ def check_axis_type(axis, type_int=True, type_tuple=True, type_list=True):
 
 def check_and_canonicalize_axes(axes, ndim):
     """Check whether the types and values of input axes are valid."""
+
     def _check(axes, ax, ndim):
         if not isinstance(ax, int):
             raise TypeError(f"Each axis should be integer, but got {type(ax)} in {axes}.")
@@ -1091,8 +1106,8 @@ def check_csr_tensor_shape(indptr_shp, indices_shp, values_shp, csr_shp):
                          f"{len(csr_shp)}")
     if values_shp[1:] != csr_shp[2:]:
         raise ValueError(f"CSRTensor's shape[2: ] must be equal to value's shape[1: ]," \
-                         f"but CSRTensor's shape[2: ] got: {csr_shp[2: ]} and value's shape[1: ]" \
-                         f"got: {values_shp[1: ]}")
+                         f"but CSRTensor's shape[2: ] got: {csr_shp[2:]} and value's shape[1: ]" \
+                         f"got: {values_shp[1:]}")
 
 
 def check_csr_tensor_dtype(indptr_dtype, indices_dtype):
@@ -1370,9 +1385,35 @@ def check_hook_fn(hook_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.")
+    tensor_hook_func_args_num = 1
+    pre_hook_func_args_num = 2
+    forward_hook_and_backward_hook_func_args_num = 3
+    # Real args number, exclude class method self param
+    hook_fn_args_num = len(inspect.signature(hook_fn).parameters)
+
+    if hook_type == "register_hook" and hook_fn_args_num != tensor_hook_func_args_num:
+        raise TypeError(f"Tensor hook function {hook_fn.__name__} arg num should be {tensor_hook_func_args_num}, but "
+                        f"got {hook_fn_args_num}")
+
+    if hook_type == "register_forward_pre_hook" and hook_fn_args_num != pre_hook_func_args_num:
+        raise TypeError(f"forward_pre_hook function {hook_fn.__name__} args num should be {pre_hook_func_args_num}, "
+                        f"but got {hook_fn_args_num}")
+
+    if (hook_type == "register_forward_hook" and
+            hook_fn_args_num != forward_hook_and_backward_hook_func_args_num):
+        raise TypeError(f"forward_hook function {hook_fn.__name__} args num should be "
+                        f"{forward_hook_and_backward_hook_func_args_num}, but got {hook_fn_args_num}")
+
+    if hook_type == "register_backward_pre_hook" and hook_fn_args_num != pre_hook_func_args_num:
+        raise TypeError(f"backward_pre_hook function {hook_fn.__name__} args num should be {pre_hook_func_args_num},"
+                        f" but got {hook_fn_args_num}")
+
+    if (hook_type == "register_backward_hook" and
+            hook_fn_args_num != forward_hook_and_backward_hook_func_args_num):
+        raise TypeError(f"backward_hook function {hook_fn.__name__} args num should be "
+                        f"{forward_hook_and_backward_hook_func_args_num}, but got {hook_fn_args_num}")
 
     return True
 
+
 _set_record = {}

mindspore/_extends/parse/compile_config.py

@@ -12,6 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+"""
+Name: AUTO_PASSES_OPTIMIZE_PATH
+Function: Whether to do optimize the passes configure.
+Value Range:
+    string: The passes configure file path.
+    Default: '' .empty string. Disable to do optimize the passes.
+"""
+AUTO_PASSES_OPTIMIZE_PATH = ''
+
 """
 Name: COMPILE_PROFILE
 Function: Whether to do profile and print profile log.
@@ -29,6 +38,16 @@ Value Range:
 """
 COMPILE_PROFILE_FINISH_ACTION = ''
 
+"""
+Name: DEBUG_MODE
+Function: Whether to compile in debug mode.
+Value Range:
+    "debug": Debug mode
+    "release": Release mode
+    Default: "debug"
+"""
+COMPILE_DEBUG_MODE = ''
+
 """
 Name: FALLBACK_SUPPORT_LIST_DICT_INPLACE
 Function: Whether to support the inplace operation of list and dict.
@@ -230,9 +249,28 @@ Value Range:
 """
 DUMP_VALIDATE_BEFORE_RESET_ID = ''
 
+"""
+Name: ENABLE_RECOMPUTE_BEFORE_INLINE
+Function: Whether to do recomputation before fprop and bprop being inlined.
+Value Range:
+    1: Enable
+    Default: Disable.
+"""
+ENABLE_RECOMPUTE_BEFORE_INLINE = ''
+
+"""
+Name: STRICT_CHECK_PARENT_CONTEXT
+Function: Whether to check parent context strictly.
+Value Range:
+    1: Enable
+    Default: Disable.
+"""
+STRICT_CHECK_PARENT_CONTEXT = ''
+
 __all__ = [
     "COMPILE_PROFILE",
     "COMPILE_PROFILE_FINISH_ACTION",
+    "COMPILE_DEBUG_MODE",
     "FALLBACK_SUPPORT_LIST_DICT_INPLACE",
     "FALLBACK_FORCE_ANY",
     "IF_PARALLEL_CALL",
@@ -255,4 +293,7 @@ __all__ = [
     "DUMP_IR_DDE_DETAIL",
     "COMBINE_LIKE_GRAPHS",
     "DUMP_VALIDATE_BEFORE_RESET_ID",
+    "ENABLE_RECOMPUTE_BEFORE_INLINE",
+    "STRICT_CHECK_PARENT_CONTEXT",
+    "AUTO_PASSES_OPTIMIZE_PATH",
 ]

mindspore/_extends/parse/parser.py

@@ -127,7 +127,7 @@ _modules_from_mindspore = (
     "mindspore_rl", "mindformers", "mindpet", "mindpose", "mindface", "mindsearch", "mindinsight", "mindelec",
     "mindflow", "mindsponge", "mindearth", "sciai", "mindquantum", "mindarmour", "mindpandas", "mindvision",
     "mindspore_gl", "mindspore_federated", "mindspore_gs", "mindspore_serving", "mindspore_xai", "mindspore_hub",
-    "ringmo_framework", "troubleshooter", "mindtorch",
+    "ringmo_framework", "troubleshooter", "mindtorch", "mindchemistry",
 )
 
 _global_params = {}
@@ -203,7 +203,7 @@ def get_parse_method_of_class(obj, parse_method=None):
     if parse_method is not None:
         method_name = parse_method
     elif isinstance(obj, nn.Cell):
-        if obj._enable_backward_hook:
+        if obj._backward_hook:
             method_name = "_backward_hook_construct"
         else:
             method_name = "construct"
@@ -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/master/design/dynamic_graph_and_static_graph.html \n")
+                         f"https://www.mindspore.cn/docs/zh-CN/master/model_train/program_form/overview.html \n")
     return convert_class_to_function_map.get(cls_str)
 
 
@@ -931,7 +931,7 @@ class ThirdPartyLibraryChecker:
     """
     def __init__(self):
         self.user_workspace_dir = self.get_top_level_module_path(os.getcwd())
-        self.python_builtin_dir = os.path.abspath(os.path.dirname(os.__file__))
+        self.python_builtin_dir = os.path.realpath(os.path.dirname(os.__file__))
 
     @staticmethod
     def get_jit_modules():
@@ -963,8 +963,8 @@ class ThirdPartyLibraryChecker:
 
     def get_top_level_module_path(self, module_path):
         """Get the path of the top level package of the current working directory."""
-        module_abspath = os.path.abspath(module_path)
-        upper_path = os.path.abspath(os.path.dirname(module_abspath))
+        module_abspath = os.path.realpath(module_path)
+        upper_path = os.path.realpath(os.path.dirname(module_abspath))
         if module_abspath == upper_path:
             return module_abspath
         # Check whether __init__.py exists in the upper directory.
@@ -990,7 +990,7 @@ class ThirdPartyLibraryChecker:
         # A modules without __file__ attribute is considered to be in user workspace.
         if not hasattr(module, '__file__'):
             return False
-        module_path = os.path.abspath(module.__file__)
+        module_path = os.path.realpath(module.__file__)
         # Python builtin modules are treated as third-party libraries.
         if module_path.startswith(self.python_builtin_dir):
             logger.debug(f"Found python builtin module '{module.__name__}', which is a third-party module.")
@@ -1180,6 +1180,7 @@ class Parser:
         return SYNTAX_SUPPORTED
 
     def check_lambda(self, src):
+        """Check if the lamda expressions is correct."""
         obj_type = get_obj_type(self.fn)
         if (obj_type != RESOLVE_TYPE_FUNCTION or src[:4] == "def ") and is_lambda_function(self.fn):
             logger.debug("fn is lambda: %r", self.fn)
@@ -1242,6 +1243,7 @@ class Parser:
         return None, None
 
     def get_name_from_namespace(self, value):
+        """Get the name of value from namespace"""
         try:
             value_str = value.__name__
             logger.debug(

mindspore/_extends/parse/standard_method.py

@@ -26,6 +26,7 @@ from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 from mindspore.ops.operations._sequence_ops import TensorToTuple
+from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -69,6 +70,38 @@ itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
 
 nan_tensor = Tensor(float('nan'), dtype=mstype.float32)
 
+_map = composite.HyperMap()
+
+
+def hypermap_dynamic_tuple(func, *inputs):
+    """Make hypermap for dynamic shape tuple."""
+    iter_len = len(inputs[0])
+    i = 0
+    ret = F.make_tuple()
+    while i < iter_len:
+        cur_input = F.make_tuple()
+        for m in inputs:
+            cur_input = cur_input + F.make_tuple(m[i])
+        new_out = _map(func, *cur_input)
+        ret = ret + F.make_tuple(new_out)
+        i = i + 1
+    return ret
+
+
+def hypermap_dynamic_list(func, *inputs):
+    """Make hypermap for dynamic shape list."""
+    iter_len = len(inputs[0])
+    i = 0
+    ret = F.make_list()
+    while i < iter_len:
+        cur_input = F.make_tuple()
+        for m in inputs:
+            cur_input = cur_input + F.make_tuple(m[i])
+        new_out = _map(func, *cur_input)
+        ret = ret + F.make_list(new_out)
+        i = i + 1
+    return ret
+
 
 def mean(x, axis=None, keep_dims=False):
     """
@@ -1598,17 +1631,7 @@ def trace(x, offset=0, axis1=0, axis2=1, dtype=None):
         >>> print(x.trace())
         3.0
     """
-    if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
-        return F.trace(x)
-    d = x.diagonal(offset, axis1=axis1, axis2=axis2)
-    shape = d.shape
-    if dtype is None:
-        dtype = d.dtype
-    dtype = check_astype_dtype_const(dtype)
-    if shape[-1] == 0:
-        return F.fill(dtype, shape[:-1], 0)
-    res = F.reduce_sum(d.astype(mstype.float32), -1)
-    return res.astype(dtype)
+    return trace_v2_op(x, offset, axis1, axis2, dtype)
 
 
 def take(x, indices, axis=None, mode='clip'):
@@ -1794,7 +1817,7 @@ def searchsorted(x, v, side='left', sorter=None):
             no suitable index, return either 0 or N (where N is the length of `a`).
         sorter (Union[int, float, bool, list, tuple, Tensor]): 1-D optional array of
             integer indices that sort array `a` into ascending order. They are typically
-            the result of argsort.
+            the result of argsort. CPU and GPU can only use default values
 
     Returns:
         Tensor, array of insertion points with the same shape as `v`.
@@ -2435,6 +2458,7 @@ def list_func(data):
         ret = ret + F.make_list(i)
     return ret
 
+
 def tuple_func(data):
     """Implementation of `tuple`."""
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
@@ -2453,7 +2477,7 @@ def tuple_func(data):
 
 
 def ms_zip(*data):
-    """Implementation of `tuple`."""
+    """Packs elements in the corresponding positions in multiple sequences into tuples."""
     x = ()
     for i in data:
         if isinstance(i, Tensor):
@@ -3002,7 +3026,7 @@ def tensor_scatter_mul(input_x, indices, updates):
     `indices`, with values from `updates`. When multiple value are given for the same index,
     the output result will be the division of values.
     """
-    return F.tensor_sactter_mul(input_x, indices, updates)
+    return F.tensor_scatter_mul(input_x, indices, updates)
 
 
 def tensor_sactter_div(input_x, indices, updates):
@@ -3813,6 +3837,20 @@ def addmm(x, mat1, mat2, *, beta=1, alpha=1):
     return F.addmm(x, mat1, mat2, beta=beta, alpha=alpha)
 
 
+def addmm_(self, mat1, mat2, *, beta=1, alpha=1):
+    r"""
+    For details, please refer to :func:`mindspore.ops.addmm`.
+
+    .. note::
+        The output results are directly updated in the Tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    """
+    return inplace_addmm_op(self, mat1, mat2, beta=beta, alpha=alpha)
+
+
 def addmv(x, mat, vec, beta=1, alpha=1):
     r"""
     Multiplies matrix `mat` and vector `vec`. The vector `x` is added to the final result.