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

mindspore/common/dtype.py

@@ -17,21 +17,25 @@
 """Data type for MindSpore."""
 from __future__ import absolute_import
 
+import builtins
 import enum
 from inspect import isfunction
 import numpy as np
+from mindspore import log as logger
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
-from mindspore._c_expression.np_dtypes import np_version_valid
+from mindspore._c_expression.np_dtypes import np_dtype_valid
 
-if np_version_valid(False):
+if np_dtype_valid(False):
     from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
+# bool, int, float are not defined in __all__ to avoid conflict with built-in types.
 __dtype__ = [
+    "bool_",
     "int8", "byte",
     "int16", "short",
     "int32", "intc",
-    "int64", "intp",
+    "int64", "long", "intp",
     "uint8", "ubyte",
     "uint16", "ushort",
     "uint32", "uintc",
@@ -39,17 +43,15 @@ __dtype__ = [
     "float16", "half",
     "float32", "single",
     "float64", "double",
-    "bool_", "float_",
-    "list_", "tuple_",
-    "int_", "uint",
+    "complex64", "cfloat",
+    "complex128", "cdouble",
+    "qint4x2", "bfloat16",
+    "float8_e4m3fn", "float8_e5m2", "hifloat8",
+    "int_", "uint", "float_",
+    "list_", "tuple_", "string",
     "number", "tensor_type",
-    "string", "type_none",
-    "TensorType", "_null",
-    "Type", "Int",
-    "complex64", "complex128",
-    "bfloat16", "qint4x2",
-    "float8_e4m3fn", "float8_e5m2",
-    "hifloat8"
+    "type_none", "_null",
+    "TensorType", "Type", "Int",
 ]
 
 __method__ = [
@@ -62,16 +64,18 @@ __all__.extend(__dtype__)
 __all__.extend(__method__)
 
 # type definition
-bool_ = typing.kBool
+bool = typing.kBool
+bool_ = bool
 
-qint4x2 = typing.kInt4
 int8 = typing.kInt8
 byte = int8
 int16 = typing.kInt16
 short = int16
 int32 = typing.kInt32
+int = int32
 intc = int32
 int64 = typing.kInt64
+long = int64
 intp = int64
 
 uint8 = typing.kUInt8
@@ -86,15 +90,21 @@ uintp = uint64
 float16 = typing.kFloat16
 half = float16
 float32 = typing.kFloat32
+float = float32
 single = float32
 float64 = typing.kFloat64
 double = float64
+
+qint4x2 = typing.kInt4
 float8_e4m3fn = typing.kFloat8E4M3FN
 float8_e5m2 = typing.kFloat8E5M2
 hifloat8 = typing.kHiFloat8
 bfloat16 = typing.kBFloat16
+
 complex64 = typing.kComplex64
+cfloat = complex64
 complex128 = typing.kComplex128
+cdouble = complex128
 
 number = typing.kNumber
 int_ = typing.kInt
@@ -137,41 +147,25 @@ AnythingType = typing.TypeAny
 RefType = typing.RefType
 _NullType = typing.TypeNull
 
-number_type = (int8,
-               int16,
-               int32,
-               int64,
-               uint8,
-               uint16,
-               uint32,
-               uint64,
-               float16,
-               float32,
-               float64,
-               bfloat16,
-               complex64,
-               complex128,
-               qint4x2,
-               float8_e4m3fn,
-               float8_e5m2,
-               hifloat8)
+number_type = (int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, bfloat16, complex64,
+               complex128, qint4x2, float8_e4m3fn, float8_e5m2, hifloat8)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
 float_type = (float16, float32, float64, bfloat16, float8_e4m3fn, float8_e5m2, hifloat8)
-signed_type = (int8, byte, int16, short, int32, intc, int64, intp, float16, half, float32, single, float64, double,
-               bfloat16, complex64, complex128, float8_e4m3fn, float8_e5m2, hifloat8)
+signed_type = (int8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128, qint4x2,
+               float8_e4m3fn, float8_e5m2, hifloat8)
 complex_type = (complex64, complex128,)
-all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128,
-             float8_e4m3fn, float8_e5m2, hifloat8)
+all_types = (bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, bfloat16,
+             complex64, complex128, qint4x2, float8_e4m3fn, float8_e5m2, hifloat8)
 
 _simple_types = {
     list: list_,
     tuple: tuple_,
     type(None): type_none,
-    bool: bool_,
-    int: int64,
-    float: float64,
+    builtins.bool: bool_,
+    builtins.int: int64,
+    builtins.float: float64,
     complex: complex128,
     str: string,
     np.bool_: bool_,
@@ -194,6 +188,9 @@ def pytype_to_dtype(obj):
     """
     Convert python type to MindSpore type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         obj (type): A python type object.
 
@@ -209,6 +206,15 @@ def pytype_to_dtype(obj):
         >>> print(out)
         Bool
     """
+    logger.warning("The interface 'mindspore.pytype_to_dtype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _pytype_to_dtype(obj)
+
+
+def _pytype_to_dtype(obj):
+    """
+    Convert python type to MindSpore type.
+    """
 
     if isinstance(obj, np.dtype):
         obj = obj.type
@@ -226,6 +232,9 @@ def get_py_obj_dtype(obj):
     """
     Get the MindSpore data type, which corresponds to python type or variable.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         obj (type): An object of python type, or a variable of python type.
 
@@ -237,6 +246,15 @@ def get_py_obj_dtype(obj):
         >>> ms.get_py_obj_dtype(1)
         mindspore.int64
     """
+    logger.warning("The interface 'mindspore.get_py_obj_dtype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _get_py_obj_dtype(obj)
+
+
+def _get_py_obj_dtype(obj):
+    """
+    Get the MindSpore data type, which corresponds to python type or variable.
+    """
     # Tensor
     if hasattr(obj, 'shape') and hasattr(obj, 'dtype') and isinstance(obj.dtype, typing.Type):
         return TensorType(obj.dtype)
@@ -260,6 +278,9 @@ def dtype_to_nptype(type_):
     r"""
     Convert MindSpore dtype to numpy data type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         type\_ (:class:`mindspore.dtype`): MindSpore's dtype.
 
@@ -271,6 +292,15 @@ def dtype_to_nptype(type_):
         >>> ms.dtype_to_nptype(ms.int8)
         <class 'numpy.int8'>
     """
+    logger.warning("The interface 'mindspore.dtype_to_nptype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _dtype_to_nptype(type_)
+
+
+def _dtype_to_nptype(type_):
+    """
+    Convert MindSpore dtype to numpy data type.
+    """
     _dtype_nptype_dict = {
         bool_: np.bool_,
         int8: np.int8,
@@ -288,7 +318,7 @@ def dtype_to_nptype(type_):
         complex128: np.complex128,
     }
     if type_ == bfloat16:
-        if not np_version_valid(True):
+        if not np_dtype_valid(True):
             raise TypeError(
                 "The Numpy bfloat16 data type is not supported now, please ensure that the current "
                 "Numpy version is not less than the version when the mindspore is compiled, "
@@ -302,6 +332,9 @@ def dtype_to_pytype(type_):
     r"""
     Convert MindSpore dtype to python data type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         type\_ (:class:`mindspore.dtype`): MindSpore's dtype.
 
@@ -314,23 +347,31 @@ def dtype_to_pytype(type_):
         >>> print(out)
         <class 'bool'>
     """
+    logger.warning("The interface 'mindspore.dtype_to_pytype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _dtype_to_pytype(type_)
+
 
+def _dtype_to_pytype(type_):
+    """
+    Convert MindSpore dtype to python data type.
+    """
     return {
-        bool_: bool,
-        int_: int,
-        int8: int,
-        int16: int,
-        int32: int,
-        int64: int,
-        uint8: int,
-        uint16: int,
-        uint32: int,
-        uint64: int,
-        float_: float,
-        float16: float,
-        float32: float,
-        float64: float,
-        bfloat16: float,
+        bool_: builtins.bool,
+        int_: builtins.int,
+        int8: builtins.int,
+        int16: builtins.int,
+        int32: builtins.int,
+        int64: builtins.int,
+        uint8: builtins.int,
+        uint16: builtins.int,
+        uint32: builtins.int,
+        uint64: builtins.int,
+        float_: builtins.float,
+        float16: builtins.float,
+        float32: builtins.float,
+        float64: builtins.float,
+        bfloat16: builtins.float,
         list_: list,
         tuple_: tuple,
         string: str,
@@ -417,7 +458,7 @@ class QuantDtype(enum.Enum):
     def __str__(self):
         return f"{self.name}"
 
-    def value(self) -> int:
+    def value(self) -> builtins.int:
         """
         Return value of `QuantDtype`. This interface is currently used to serialize or deserialize `QuantDtype`
         primarily.

mindspore/common/dump.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-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.
@@ -14,115 +14,14 @@
 # ============================================================================
 """Controlling dump behavior."""
 from __future__ import absolute_import
-from warnings import warn
-
-import mindspore.context as context
-from mindspore._c_expression import security
+from mindspore.tools import set_dump as tools_set_dump
+from mindspore.common._decorator import deprecated
 
 
+@deprecated("2.7.1", "mindspore.tools.set_dump", module_prefix="mindspore.")
 def set_dump(target, enabled=True):
     """
-    Enable or disable dump for the `target` and its contents.
-
-    `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when the Dump function is enabled, and the `dump_mode`
-    field in the Dump configuration file is set to `"2"` with the `ms_backend` compilation backend
-    (please refer to the backend parameter in
-    `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_).
-    See the `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
-    The default enabled status for
-    a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
-
-    Note:
-        1. This API is only available for JIT compilation, requires 'Ascend' as the device_target and
-           `ms_backend` as the compilation backend (please refer to the backend parameter in
-           `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_),
-           and does not support fused operators.
-        2. This API only supports being called before training starts.
-           If you call this API during training, it may not be effective.
-        3. After using `set_dump(Cell, True)` , operators in forward and backward
-           computation  (computation generated by the grad operations) of the
-           cell will be dumped.
-        4. For :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer, the forward
-           computation and backward computation use the same set of
-           operators. So you can only see dump data from backward computation.
-           Please note that :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer will also use
-           the above operators internally when initialized with `sparse=True` and
-           `reduction="mean"` .
-
-    Args:
-        target (Union[Cell, Primitive]): The Cell instance or Primitive instance
-            to which the dump flag is set.
-        enabled (bool, optional): ``True`` means enable dump, ``False`` means disable dump.
-            Default: ``True`` .
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        .. 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/en/master/debug/dump.html>`_ for details.
-
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, set_dump
-        >>>
-        >>> ms.set_device(device_target="Ascend")
-        >>>
-        >>> class MyNet(nn.Cell):
-        ...     def __init__(self):
-        ...         super().__init__()
-        ...         self.conv1 = nn.Conv2d(5, 6, 5, pad_mode='valid')
-        ...         self.relu1 = nn.ReLU()
-        ...
-        ...     @jit
-        ...     def construct(self, x):
-        ...         x = self.conv1(x)
-        ...         x = self.relu1(x)
-        ...         return x
-        >>>
-        >>> if __name__ == "__main__":
-        ...     net = MyNet()
-        ...     set_dump(net.conv1)
-        ...     input_tensor = Tensor(np.ones([1, 5, 10, 10], dtype=np.float32))
-        ...     output = net(input_tensor)
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.set_dump` instead.
     """
-    if security.enable_security():
-        raise ValueError('The set_dump API is not supported, please recompile '
-                         'source without "-s on".')
-
-    import mindspore.nn as nn  # avoid circular import
-    from mindspore.ops import Primitive
-    if not isinstance(target, nn.Cell) and not isinstance(target, Primitive):
-        raise ValueError(f"The \"target\" parameter must be an instance of "
-                         f"Cell or Primitive, "
-                         f"but got an instance of {type(target)}.")
-
-    if not isinstance(enabled, bool):
-        raise ValueError("The \"enabled\" parameter must be bool.")
-
-    # Checking for device target and mode.
-    current_target = context.get_context("device_target")
-    if current_target != "Ascend":
-        # We will not return here in case user changed device_target later.
-        warn("Current device_target is {}, which is not supported by set_dump. "
-             "Only Ascend device target is supported currently. "
-             "If you have Ascend device, consider set device_target to Ascend "
-             "before calling set_dump.".format(current_target))
-
-    # The actual set dump logic.
-    if isinstance(target, nn.Cell):
-        target.add_flags(dump=enabled)
-        for cell in target.cells():
-            set_dump(cell, enabled)
-
-        primitives = getattr(target, "_primitives", {})
-        for value in primitives.values():
-            if value and "dump" in value.attrs:
-                set_dump(value, enabled)
-
-    if isinstance(target, Primitive):
-        target.add_prim_attr("dump", "true" if enabled else "false")
+    tools_set_dump(target, enabled)

mindspore/common/{auto_dynamic_shape.py → dynamic_shape/auto_dynamic_shape.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-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.
@@ -261,7 +261,12 @@ class _AutoIdentifyDynamicShape:
                 return False
         return True
 
-    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode):
+    @staticmethod
+    def _is_invalid_shape(shape):
+        """Check if input shape is valid"""
+        return is_shape_unknown(shape) or not shape
+
+    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode, enable_jit_dynamic=False):
         """is enable auto identify shape"""
         if not is_sink_mode and not args_list:
             return False
@@ -270,10 +275,10 @@ class _AutoIdentifyDynamicShape:
                 continue
             if not isinstance(elem, (list, tuple, Tensor, int, float)):
                 return False
-            if isinstance(elem, Tensor) and (is_shape_unknown(elem.shape) or (not elem.shape)):
+            if isinstance(elem, Tensor) and self._is_invalid_shape(elem.shape) and not enable_jit_dynamic:
                 return False
             if not is_sink_mode and isinstance(elem, (list, tuple)):
-                return self._is_enable_auto_dynamic_shape(elem, is_sink_mode)
+                return self._is_enable_auto_dynamic_shape(elem, is_sink_mode, enable_jit_dynamic)
         return True
 
     @staticmethod
@@ -328,10 +333,10 @@ class _AutoIdentifyDynamicShape:
         logger.info((f'generalize with generalize shape cache, compile args shape = {res_shape}'))
         return new_generalize_shape
 
-    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode):
+    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode, enable_jit_dynamic=False):
         """generate compile args in auto dynamic shape"""
         if not self.is_enable_auto_dynamic_shape or \
-            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode) or \
+            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode, enable_jit_dynamic) or \
             not self._check_input_number_and_type(args_list):
             self.is_enable_auto_dynamic_shape = False
             return args_list
@@ -475,11 +480,13 @@ class _AutoIdentifyDynamicShape:
 _auto_dynamic_shape = _AutoIdentifyDynamicShape()
 
 
-def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False):
+def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False, enable_jit_dynamic=False):
     """get auto dynamic shape args."""
     if key_id not in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id] = _AutoIdentifyDynamicShape(enable_auto_dynamic)
-    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(compile_args, False)
+    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(
+        compile_args, False, enable_jit_dynamic
+    )
     return compile_args
 
 
@@ -487,18 +494,3 @@ def update_auto_dynamic_shape_phase(compile_args, key_id, phase):
     """update auto dynamic shape phase."""
     if key_id in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)
-
-
-def get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id, input_signature,
-                                                           enable_auto_dynamic=False):
-    """get auto dynamic shape args."""
-    if input_signature is None:
-        return get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic)
-    return compile_args
-
-
-def update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, input_signature):
-    """update auto dynamic shape phase."""
-    if input_signature is None:
-        if key_id in auto_dynamic_shape_dict:
-            auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)