mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:7f763125,[branch]:(HEAD->r2.6,origin/r2.6)''
+__commit_id__ = ''[sha1]:7edec76e,[branch]:(HEAD->r2.7,origin/r2.7)''

mindspore/__init__.py

@@ -16,10 +16,10 @@
 from __future__ import absolute_import
 
 from mindspore.run_check import run_check
-from mindspore import common, dataset, mindrecord, train, log, amp
+from mindspore import common, dataset, mindrecord, train, log, amp, device_manager
 from mindspore import profiler, communication, numpy, parallel, hal, runtime, device_context
 from mindspore.common import *
-from mindspore.common import _tensor_docs
+from mindspore.common import _tensor_docs, bool, int, float
 del _tensor_docs
 from mindspore.mindrecord import *
 from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr

mindspore/_checkparam.py

@@ -118,20 +118,21 @@ def _format_str_two_value(val1, val2, rel):
 
 
 def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret_five=False,
-                           greater_zero=True, third_one=False, three_input=False):
+                           greater_zero=True, third_one=False, three_input=False, pad_value=1):
     """
     Checks whether an argument is a positive int or tuple with 3 or 5(when allow_five is True) positive int elements.
     """
 
-    def _raise_message(third_one_flag=False, three_input_flag=False):
+    def _raise_message(third_one_flag=False, three_input_flag=False, ret_value=None):
+        ret_value = arg_value if ret_value is None else ret_value
         if third_one_flag:
             raise ValueError(f"For '{prim_name}', the depth of parameter '{arg_name}' must be 1, " \
                              f"but got {ret_value[-3]}.")
         if three_input_flag:
             raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer " \
-                             f"or a tuple of three positive integer, but got {arg_value}.")
+                             f"or a tuple of three positive integer, but got {ret_value}.")
         raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer or " \
-                         f"a tuple of three {'or five ' if allow_five else ''}positive integer, but got {arg_value}")
+                         f"a tuple of three {'or five ' if allow_five else ''}positive integer, but got {ret_value}")
 
     def _get_return_value():
         def _check():
@@ -144,9 +145,10 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
 
         _check()
         if isinstance(arg_value, int):
-            ret = (1, 1, arg_value, arg_value, arg_value) if ret_five else (arg_value, arg_value, arg_value)
+            ret = (pad_value, pad_value, 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
+            ret = (pad_value, pad_value, arg_value[0], arg_value[1], arg_value[2]) if ret_five else arg_value
         else:  # case: len(arg_value) == 5
             ret = arg_value if ret_five else (arg_value[2], arg_value[3], arg_value[4])
 
@@ -159,12 +161,12 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
                     continue
                 if not greater_zero and item >= 0:
                     continue
-            _raise_message()
+            _raise_message(ret_value=ret_value)
 
     def _check_third_one(ret_value):
         if third_one:
             if ret_value[-3] != 1:
-                _raise_message(third_one_flag=third_one)
+                _raise_message(third_one_flag=third_one, ret_value=ret_value)
 
     check_value_type(arg_name, arg_value, (int, tuple), prim_name)
     if three_input and isinstance(arg_value, tuple):
@@ -785,9 +787,9 @@ def check_astype_dtype(dtype):
     if isinstance(dtype, str):
         if dtype.lower() not in all_types:
             raise TypeError(f"For Tensor.astype, the input type must be one of {all_types}, but got '{dtype}'.")
-        dtype = mstype.pytype_to_dtype(np.dtype(dtype.lower()))
+        dtype = mstype._pytype_to_dtype(np.dtype(dtype.lower()))  # pylint:disable=protected-access
     elif isinstance(dtype, type):
-        dtype = mstype.pytype_to_dtype(dtype)
+        dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
     elif not dtype in mstype.number_type + (mstype.bool_,):
         raise TypeError(f"For Tensor.astype, the input type must be one of {mstype.number_type + (mstype.bool_,)}," \
                         f" but got '{dtype}'.")
@@ -1288,6 +1290,33 @@ def _expand_tuple(n_dimensions):
     return convert
 
 
+def _check_int_sequence_len(sequence, valid_len):
+    if not len(sequence) is valid_len:
+        raise TypeError(f"When expanding an sequence to tuple, input sequence dimension must be {valid_len}, " \
+                        f"but got {sequence}")
+    for i in sequence:
+        if not isinstance(i, int) or isinstance(i, bool):
+            raise TypeError(f"When expanding an sequence to tuple, " \
+                            f"the type of element in input sequence must be an integer, but got {type(i)}.")
+
+
+def _expand_sequence_to_tuple(n_dimensions):
+    """To expand an int number to tuple."""
+
+    def convert(m):
+        if not isinstance(m, (tuple, list)):
+            if isinstance(m, int) and not isinstance(m, bool):
+                return tuple(repeat(m, n_dimensions))
+            raise TypeError(f"When expanding an input to tuple, input type must be integer or tuple[int]/list[int], " \
+                            f"but got {type(m)}")
+        _check_int_sequence_len(m, n_dimensions)
+        if isinstance(m, list):
+            return tuple(m)
+        return m
+
+    return convert
+
+
 def _check_data_type_valid(data, valid_type):
     """Check data type valid."""
     if valid_type is None:
@@ -1342,7 +1371,9 @@ def check_output_data(data):
 once = _expand_tuple(1)
 twice = _expand_tuple(2)
 triple = _expand_tuple(3)
-
+once_sequence = _expand_sequence_to_tuple(1)
+twice_sequence = _expand_sequence_to_tuple(2)
+triple_sequence = _expand_sequence_to_tuple(3)
 
 def args_type_check(*type_args, **type_kwargs):
     """Check whether input data type is correct."""

mindspore/_extends/builtin_operations.py

@@ -19,7 +19,7 @@ from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore.common.tensor import Tensor
 import mindspore.common.dtype as mstype
-from mindspore.common.dtype import dtype_to_nptype, get_py_obj_dtype
+from mindspore.common.dtype import _dtype_to_nptype, _get_py_obj_dtype
 from mindspore._c_expression import TensorPy as CTensor
 
 
@@ -164,7 +164,7 @@ def Load(value, u=None):
 
 def scalar_cast(x, t):
     """Implement scalar_cast."""
-    np_type = dtype_to_nptype(t)
+    np_type = _dtype_to_nptype(t)  # pylint:disable=protected-access
     value = np_type(x)
     cast_value = np.ndarray.item(value)
     return cast_value
@@ -172,7 +172,7 @@ def scalar_cast(x, t):
 
 def typeof(x):
     """Implement typeof."""
-    return get_py_obj_dtype(x)
+    return _get_py_obj_dtype(x)  # pylint:disable=protected-access
 
 
 def tuple_to_array(x):

mindspore/{_deprecated → _extends/optimize}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
+# Copyright 2025 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.
@@ -12,6 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Store the deprecated api temporarily."""
+"""
+Interfaces for optimize module.
+"""
+
 from __future__ import absolute_import
-from mindspore._deprecated.jit import jit
+
+__all__ = ['set_lazy_inline']
+
+from .cell_utils import set_lazy_inline

mindspore/_extends/optimize/cell_utils.py

@@ -0,0 +1,96 @@
+# Copyright 2025 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.
+# ============================================================================
+"""
+Interfaces for optimize module.
+"""
+
+from mindspore import log as logging
+from mindspore.nn import Cell
+
+
+def process_cell_init_args(cells, reusing_count, allow_list, denny_list):
+    """
+    process all the cells to use lazy inline with the conditions..
+
+    Args:
+        cells(Object map): All the cells information.
+        reusing_count(int): The count of the same key of the cell instance.
+        allow_list:(list):  The allow list of the cell class to apply lazy inline
+        denny_list:(list):  The denny list of the cell class to apply lazy inline
+    Returns:
+        void
+    """
+    type_instance = {}
+    class_name = {}
+
+    for k in cells.keyrefs():
+        v = cells[k]
+        if k.construct.__code__.co_filename.find("mindspore/nn") != -1:
+            continue
+        if denny_list and any(deny in k.cls_name for deny in denny_list):
+            continue
+        if allow_list and not any(allow in k.cls_name for allow in allow_list):
+            continue
+
+        pickle_args = k.cls_name + str(id(k.__class__)) + "[" + str(v[1]) + ":kws:" + str(v[2]) + "]"
+
+        instances = type_instance.get(pickle_args)
+        if instances is not None:
+            instances.append(k)
+            if len(instances) > reusing_count:
+                if not hasattr(k, "cell_init_args"):
+                    setattr(k, "cell_init_args", "lazy_inline_" + pickle_args)
+                    logging.debug("Reusing cell info: %s , id: %s , args: %s",
+                                  k.construct.__code__.co_filename + "/" + k.cls_name, id(k), pickle_args)
+                    setattr(k, "no_inline", False)
+            elif len(instances) == reusing_count:
+                class_name[v[0]] = k.construct.__code__.co_filename + "/" + k.cls_name
+                logging.info("Reusing Cell: %s , args: %s", k.construct.__code__.co_filename + "/" + k.cls_name,
+                             pickle_args)
+
+                for i in instances:
+                    if not hasattr(i, "cell_init_args"):
+                        setattr(i, "cell_init_args", "lazy_inline_" + pickle_args)
+                        logging.debug("Reusing cell info: %s , id: %s , args: %s",
+                                      i.construct.__code__.co_filename + "/" + i.cls_name, id(i), pickle_args)
+                        setattr(i, "no_inline", False)
+        else:
+            type_instance[pickle_args] = [k]
+
+    return class_name
+
+
+def set_lazy_inline(reusing_count=3, allow_list=None, denny_list=None):
+    """
+    Apply all the cells to use lazy inline with the conditions.
+
+    Args:
+        cells(Object map): All the cells information.
+        reusing_count(int): The count of the same key of the cell instance.
+        allow_list:(list):  The allow list of the cell class to apply lazy inline
+        denny_list:(list):  The denny list of the cell class to apply lazy inline
+    Returns:
+        void
+    """
+    cells = Cell.global_cells
+    if denny_list is None:
+        denny_list = []
+    if allow_list is None:
+        allow_list = []
+
+    denny_list.append("_Output")
+    denny_list.append("_MicroBatch")
+    reusing_cells = process_cell_init_args(cells, reusing_count, allow_list, denny_list)
+    return reusing_cells