mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/common/dtype.py

@@ -17,25 +17,21 @@
 """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_dtype_valid
+from mindspore._c_expression.np_dtypes import np_version_valid
 
-if np_dtype_valid(False):
+if np_version_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", "long", "intp",
+    "int64", "intp",
     "uint8", "ubyte",
     "uint16", "ushort",
     "uint32", "uintc",
@@ -43,15 +39,17 @@ __dtype__ = [
     "float16", "half",
     "float32", "single",
     "float64", "double",
-    "complex64", "cfloat",
-    "complex128", "cdouble",
-    "qint4x2", "bfloat16",
-    "float8_e4m3fn", "float8_e5m2", "hifloat8",
-    "int_", "uint", "float_",
-    "list_", "tuple_", "string",
+    "bool_", "float_",
+    "list_", "tuple_",
+    "int_", "uint",
     "number", "tensor_type",
-    "type_none", "_null",
-    "TensorType", "Type", "Int",
+    "string", "type_none",
+    "TensorType", "_null",
+    "Type", "Int",
+    "complex64", "complex128",
+    "bfloat16", "qint4x2",
+    "float8_e4m3fn", "float8_e5m2",
+    "hifloat8"
 ]
 
 __method__ = [
@@ -64,18 +62,16 @@ __all__.extend(__dtype__)
 __all__.extend(__method__)
 
 # type definition
-bool = typing.kBool
-bool_ = bool
+bool_ = typing.kBool
 
+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
@@ -90,21 +86,15 @@ 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
@@ -147,25 +137,41 @@ 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, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128, qint4x2,
-               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)
 complex_type = (complex64, complex128,)
-all_types = (bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, bfloat16,
-             complex64, complex128, qint4x2, float8_e4m3fn, float8_e5m2, hifloat8)
+all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128,
+             float8_e4m3fn, float8_e5m2, hifloat8)
 
 _simple_types = {
     list: list_,
     tuple: tuple_,
     type(None): type_none,
-    builtins.bool: bool_,
-    builtins.int: int64,
-    builtins.float: float64,
+    bool: bool_,
+    int: int64,
+    float: float64,
     complex: complex128,
     str: string,
     np.bool_: bool_,
@@ -188,9 +194,6 @@ 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.
 
@@ -206,15 +209,6 @@ 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
@@ -232,9 +226,6 @@ 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.
 
@@ -246,15 +237,6 @@ 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)
@@ -278,9 +260,6 @@ 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.
 
@@ -292,15 +271,6 @@ 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,
@@ -318,7 +288,7 @@ def _dtype_to_nptype(type_):
         complex128: np.complex128,
     }
     if type_ == bfloat16:
-        if not np_dtype_valid(True):
+        if not np_version_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, "
@@ -332,9 +302,6 @@ 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.
 
@@ -347,31 +314,23 @@ 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_: 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,
+        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,
         list_: list,
         tuple_: tuple,
         string: str,
@@ -458,7 +417,7 @@ class QuantDtype(enum.Enum):
     def __str__(self):
         return f"{self.name}"
 
-    def value(self) -> builtins.int:
+    def value(self) -> int:
         """
         Return value of `QuantDtype`. This interface is currently used to serialize or deserialize `QuantDtype`
         primarily.

mindspore/common/dump.py

@@ -68,7 +68,7 @@ def set_dump(target, enabled=True):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, set_dump, jit
+        >>> from mindspore import Tensor, set_dump
         >>>
         >>> ms.set_device(device_target="Ascend")
         >>>

mindspore/common/file_system.py

@@ -14,14 +14,10 @@
 # ============================================================================
 """File system registration management"""
 from mindspore import log as logger
-from mindspore import _checkparam as Validator
-
-mindio_server_info = {"memfs.data_block_pool_capacity_in_gb": "100"}
 
 
 class FileSystem:
     """File operation interface manager"""
-
     def __init__(self):
         self.create = open
         self.create_args = ("ab",)
@@ -39,33 +35,20 @@ def _register_basic_file_system(fs: FileSystem):
     return True
 
 
-def _init_mindio():
-    """Initialize MindIO and return the module if successful"""
+def _register_mindio_file_system(fs: FileSystem):
+    """register mindio file system"""
     try:
-        import mindio_acp as mindio
-        ret = mindio.initialize(server_info=mindio_server_info)
-        if ret == 0:
-            return mindio
-        logger.warning(f"Failed to initialize mindio_acp: ret = {ret}")
+        import mindio
     except ImportError:
-        pass
+        return False
     try:
-        import mindio
         ret = mindio.initialize()
-        if ret == 0:
-            return mindio
-        logger.warning(f"Failed to initialize mindio: ret = {ret}")
-    except ImportError:
-        pass
-    return None
-
-
-def _register_mindio_file_system(fs: FileSystem):
-    """register mindio file system"""
-    mindio = _init_mindio()
-    if mindio is None:
+    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
@@ -73,36 +56,3 @@ def _register_mindio_file_system(fs: FileSystem):
     fs.backend = "mindio"
     logger.info("The weights are stored using MindIO as the backend.")
     return True
-
-
-def set_mindio_server_info(data_block_pool_capacity_in_gb=100):
-    """
-    Configure MindIO server settings.
-
-    Args:
-        data_block_pool_capacity_in_gb (int): Memory pool capacity for data blocks in gigabytes.
-    """
-    global mindio_server_info
-    Validator.check_positive_int(data_block_pool_capacity_in_gb, "data_block_pool_capacity_in_gb")
-    mindio_server_info["memfs.data_block_pool_capacity_in_gb"] = str(data_block_pool_capacity_in_gb)
-
-
-def mindio_preload(ckpt_file_name):
-    """
-    Preload data into memory using MindIO for faster access.
-
-    Args:
-        ckpt_file_name (str): Checkpoint file name.
-
-    Returns:
-        bool: True if preloading is successful, False otherwise.
-    """
-    Validator.check_value_type('ckpt_file_name', ckpt_file_name, str, "mindio_preload")
-    mindio = _init_mindio()
-    if mindio is None:
-        return False
-    if not hasattr(mindio, 'preload'):
-        logger.warning("MindIO module does not have preload method")
-        return False
-    mindio.preload(ckpt_file_name)
-    return True

mindspore/common/hook_handle.py

@@ -16,21 +16,6 @@
 from __future__ import absolute_import
 import weakref
 from mindspore._c_expression import TensorPy as Tensor_
-from mindspore._check_jit_forbidden_api import jit_forbidden_register
-
-
-# Global variable to mark the `Parameter` hook and `Cell` hook version
-_HOOK_VERSION = 0
-
-
-def _update_hook_version():
-    global _HOOK_VERSION
-    _HOOK_VERSION += 1
-
-
-def _hook_version():
-    global _HOOK_VERSION
-    return _HOOK_VERSION
 
 
 class _TensorHookHandle:
@@ -46,9 +31,8 @@ class _TensorHookHandle:
 
     def __init__(self, tensor):
         self.id = None
-        self.tensor_weakref = weakref.ref(tensor)
+        self.tensor_ref = weakref.ref(tensor)
 
-    @jit_forbidden_register
     def remove(self):
         """
         Remove the tensor hook function, which corresponds to this '_TensorHookHandle' object.
@@ -83,9 +67,9 @@ class _TensorHookHandle:
         """
         if self.id is not None:
             Tensor_.remove_hook(self.id)
-            tensor = self.tensor_weakref()
+            tensor = self.tensor_ref()
             if tensor is not None:
-                tensor._remove_hook()  # pylint:disable=protected-access
+                tensor._remove_hook() # pylint:disable=protected-access
 
 
 class HookHandle:
@@ -115,7 +99,6 @@ class HookHandle:
             if extra_dict is not None:
                 self.extra_dict_ref = weakref.ref(extra_dict)
 
-    @jit_forbidden_register
     def remove(self):
         """
         Remove the cell hook function, which corresponds to this 'HookHandle' object.
@@ -162,8 +145,6 @@ class HookHandle:
             (Tensor(shape=[1], dtype=Float32, value= [ 2.00000000e+00]), Tensor(shape=[1], dtype=Float32,
             value= [ 2.00000000e+00]))
         """
-        _update_hook_version()  # pylint:disable=protected-access
-
         if self.hook_dict_ref is not None:
             hook_dict = self.hook_dict_ref()
             if hook_dict is not None and self.handle_id in hook_dict:

mindspore/common/np_dtype.py

@@ -16,10 +16,10 @@
 # ============================================================================
 """Numpy data type for MindSpore."""
 
-from mindspore._c_expression.np_dtypes import np_dtype_valid
-if np_dtype_valid(True):
+from mindspore._c_expression.np_dtypes import np_version_valid
+if np_version_valid(True):
     from mindspore._c_expression.np_dtypes import bfloat16 # pylint: disable=unused-import
 
 __all__ = []
-if np_dtype_valid(False):
+if np_version_valid(False):
     __all__.extend(["bfloat16"])

mindspore/common/parameter.py

@@ -33,7 +33,6 @@ from mindspore import context
 from mindspore.common._utils import get_slice_num, get_slice_shape
 from mindspore.common.initializer import initializer
 from mindspore.common.tensor import Tensor, _TensorMeta
-from mindspore.common.hook_handle import _update_hook_version
 from mindspore import _checkparam as Validator
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore._c_expression import TensorPy as Tensor_
@@ -72,6 +71,19 @@ def _is_parameter_generated(param_name):
 # 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."""
@@ -80,7 +92,7 @@ def _is_in_auto_parallel_mode():
 
 def _is_parallel_mode():
     """ Whether is parallel mode """
-    if not _is_initialized():
+    if not _is_initialized() or context.get_context('mode') == context.PYNATIVE_MODE:
         return False
     if os.getenv("RUN_MODE") != "predict":
         return False
@@ -418,6 +430,10 @@ class Parameter(Tensor_):
                                "1. context.set_ps_context(enable_ps=True) \n"
                                "2. export MS_ROLE environment variable \n"
                                "Please refer to the official website for detailed usage.")
+
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise RuntimeError("Parameter server training is not supported in pynative mode currently."
+                               "Please switch to graph mode and retry.")
         self.is_param_ps = True
         self.init_in_server = init_in_server
         self.param_info.init_in_server = init_in_server
@@ -1007,11 +1023,11 @@ class Parameter(Tensor_):
         For details, please refer to :func:`mindspore.Tensor.register_hook`.
         """
         handle = Tensor.register_hook(self, hook_fn)
-        _update_hook_version()
+        set_parameter_hook_updated(True)
         return handle
 
     def _remove_hook(self):
-        _update_hook_version()
+        set_parameter_hook_updated(True)
 
     def _offload(self):
         r"""

mindspore/common/recompute.py

@@ -18,6 +18,7 @@ from collections import OrderedDict
 from types import MethodType
 from mindspore import log as logger
 from mindspore.nn.cell import Cell
+from mindspore import context
 from mindspore.common.tensor import Tensor
 from mindspore import ops
 from mindspore.ops.composite import GradOperation
@@ -26,7 +27,6 @@ from mindspore.common.api import _pynative_executor, _no_grad
 from mindspore.common.generator import get_rng_state, set_rng_state
 from mindspore.train.amp import AmpDecorator
 from mindspore._c_expression.amp import get_curr_amp_strategy
-from mindspore._check_jit_forbidden_api import jit_forbidden_register
 
 
 class _WrapCell(Cell):
@@ -211,12 +211,14 @@ def _detach_input(input_arg):
 def _check_validation(block):
     if not isinstance(block, Cell):
         raise TypeError("Recompute function now only support block which inherited from Cell!")
+    if context.get_context("mode") != context.PYNATIVE_MODE:
+        raise AssertionError("Recompute function now only support pynative mode, you can use "
+                             "Cell.recompute() in graph mode.")
     if block.construct.__code__.co_name == "staging_specialize":
         logger.warning('Block\'s construct method decorated by @jit that recompute '
                        'function will not come into effect.')
 
 
-@jit_forbidden_register
 def recompute(block, *args, **kwargs):
     r"""
     This function is used to reduce memory, when run block, rather than