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

mindspore/common/auto_dynamic_shape.py

@@ -182,15 +182,15 @@ class _AutoDynamicShapeManager:
 
     def _compare_input_args_and_cache_args(self, input_args, cache_args):
         """compare input args and cache args"""
-        for (input, cache) in zip(input_args, cache_args):
-            if isinstance(input, Tensor) and isinstance(cache, Tensor):
-                if not self.is_tensor_equal(input, cache):
+        for (arg, cache) in zip(input_args, cache_args):
+            if isinstance(arg, Tensor) and isinstance(cache, Tensor):
+                if not self.is_tensor_equal(arg, cache):
                     return False
-            elif isinstance(input, int) and isinstance(cache, int):
-                if input != cache:
+            elif isinstance(arg, int) and isinstance(cache, int):
+                if arg != cache:
                     return False
-            elif isinstance(input, (tuple, list)) and isinstance(cache, (tuple, list)):
-                if not self._compare_input_args_and_cache_args(input, cache):
+            elif isinstance(arg, (tuple, list)) and isinstance(cache, (tuple, list)):
+                if not self._compare_input_args_and_cache_args(arg, cache):
                     return False
         return True
 
@@ -287,21 +287,21 @@ class _AutoIdentifyDynamicShape:
 
 
     @staticmethod
-    def _do_generalize_in_sink(arg, cache, input_index, cache_index, cache_type):
+    def _do_generalize_in_sink(input_arg, cache, input_index, cache_index, cache_type):
         """do generalize in sink, input rank must be 2"""
-        if not arg:
+        if not input_arg:
             raise ValueError("In sink mode, cell input can not be scalar.")
 
-        if arg == cache:
+        if input_arg == cache:
             return cache
 
         shape_value = []
-        if len(arg) != len(cache):
+        if len(input_arg) != len(cache):
             shape_value.append(SHAPE_RANK_ANY)
         else:
-            for _ in arg:
+            for _ in input_arg:
                 shape_value.append(SHAPE_DIM_ANY)
-        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {arg},'
+        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {input_arg},'
                      f'cache shape is {cache}, not equal, need generalize to {shape_value}.'))
         return shape_value
 
@@ -312,6 +312,20 @@ class _AutoIdentifyDynamicShape:
         self.auto_dynamic_shape_manager.update_phase_and_compile_args(args, phase, self.save_cache_number,
                                                                       is_sink_mode, aux)
 
+    def _check_real_shape_cache(self, res_shape, args_list):
+        """find cache in real_shape_cache"""
+        real_cache_number = self.auto_dynamic_shape_manager.get_real_shape_cache_number()
+        if real_cache_number < 2:
+            logger.info((f'real shape cache cap is {real_cache_number}, smaller than 2, '
+                         f'compile args shape={res_shape}.'))
+            return True
+
+        is_real_shape_exist = self.auto_dynamic_shape_manager.find_compile_args_in_shape_cache(args_list, "real")
+        if is_real_shape_exist:
+            logger.debug((f'find compile args in real shape cache, compile args shape={res_shape}'))
+            return True
+
+        return False
 
     def _generate_with_generalize_shape(self, generalize_shape_args, is_sink_mode, args_list):
         """generate with generalize_shape """
@@ -440,7 +454,6 @@ class _AutoIdentifyDynamicShape:
         return generalize_one_shape, True
 
 
-
     def _do_generalize_shape(self, cache_type, input_args, is_sink_mode):
         """do generalize shape by cache"""
         shape_cache = self.auto_dynamic_shape_manager.get_cache_by_type(cache_type)

mindspore/common/dtype.py

@@ -22,6 +22,9 @@ from inspect import isfunction
 import numpy as np
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
+from mindspore._c_expression.np_dtypes import np_version_valid
+if np_version_valid(False):
+    from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
 __dtype__ = [
     "int8", "byte",
@@ -43,7 +46,7 @@ __dtype__ = [
     "TensorType", "_null",
     "Type", "Int",
     "complex64", "complex128",
-    "bfloat16"
+    "bfloat16", "qint4x2"
 ]
 
 __method__ = [
@@ -58,6 +61,7 @@ __all__.extend(__method__)
 # type definition
 bool_ = typing.Bool()
 
+qint4x2 = typing.Int(4)
 int8 = typing.Int(8)
 byte = int8
 int16 = typing.Int(16)
@@ -140,11 +144,12 @@ number_type = (int8,
                float64,
                bfloat16,
                complex64,
-               complex128,)
+               complex128,
+               qint4x2,)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64,)
+float_type = (float16, float32, float64, bfloat16,)
 signed_type = (int8, byte, int16, short, int32, intc, int64,
                intp, float16, half, float32, single, float64,
                double, bfloat16, complex64, complex128)
@@ -258,8 +263,7 @@ def dtype_to_nptype(type_):
         >>> ms.dtype_to_nptype(ms.int8)
         <class 'numpy.int8'>
     """
-
-    return {
+    _dtype_nptype_dict = {
         bool_: np.bool_,
         int8: np.int8,
         int16: np.int16,
@@ -274,8 +278,10 @@ def dtype_to_nptype(type_):
         float64: np.float64,
         complex64: np.complex64,
         complex128: np.complex128,
-        bfloat16: np.float32,
-    }[type_]
+    }
+    if np_version_valid(False):
+        _dtype_nptype_dict.update({bfloat16: np_bfloat16})
+    return _dtype_nptype_dict[type_]
 
 
 def dtype_to_pytype(type_):
@@ -348,8 +354,9 @@ class QuantDtype(enum.Enum):
     """
     An enum for quant datatype, contains `INT1` ~ `INT16`, `UINT1` ~ `UINT16`.
 
-    `QuantDtype` is defined in `dtype.py <https://gitee.com/mindspore/mindspore/tree/r2.2/mindspore/python/mindspore/
-    common/dtype.py>`_, use command below to import:
+    `QuantDtype` is defined in
+    `dtype.py <https://gitee.com/mindspore/mindspore/blob/master/mindspore/python/mindspore/common/dtype.py>`_ ,
+    use command below to import:
 
     .. code-block::
 
@@ -357,7 +364,7 @@ class QuantDtype(enum.Enum):
 
     Tutorial Examples:
         - `Quantization algorithm in Golden Stick
-          <https://www.mindspore.cn/golden_stick/docs/en/r0.3/quantization/slb.html
+          <https://www.mindspore.cn/golden_stick/docs/en/master/quantization/slb.html
           #applying-the-quantization-algorithm>`_
     """
     INT1 = 0

mindspore/common/dump.py

@@ -25,22 +25,19 @@ 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 Asynchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document <https://www.mindspore.cn/tutorials/
-    experts/en/r2.2/debug/dump.html>`_ for details. The default enabled status for
+    Please note that this API takes effect only when Synchronous Dump is enabled and the `dump_mode`
+    field in dump config file is ``"2"`` . See the `dump document
+    <https://www.mindspore.cn/docs/en/master/model_train/debug/dump.html>`_ for details.
+    The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Note:
-        1. This API is only effective for GRAPH_MODE with Ascend backend.
-        2. This API only supports being called before training starts.
+        1. 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
+        2. 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
+        3. 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
@@ -60,7 +57,7 @@ def set_dump(target, enabled=True):
         .. 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/experts/en/r2.2/debug/dump.html>`_ for details.
+            See `dump document <https://www.mindspore.cn/docs/en/master/model_train/debug/dump.html>`_ for details.
 
         >>> import numpy as np
         >>> import mindspore as ms

mindspore/common/file_system.py

@@ -0,0 +1,48 @@
+# Copyright 2024 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.
+# ============================================================================
+"""File system registration management"""
+
+
+class FileSystem:
+    """File operation interface manager"""
+    def __init__(self):
+        self.create = open
+        self.create_args = ("ab",)
+        self.open = open
+        self.open_args = ("rb",)
+
+
+def _register_basic_file_system(fs: FileSystem):
+    """register basic file system"""
+    fs.create = open
+    fs.create_args = ("ab",)
+    fs.open = open
+    fs.open_args = ("rb",)
+    return True
+
+
+def _register_mindio_file_system(fs: FileSystem):
+    """register mindio file system"""
+    try:
+        import mindio
+    except ImportError:
+        return False
+    if mindio.initialize() != 0:
+        return False
+    fs.create = mindio.create_file
+    fs.create_args = ()
+    fs.open = mindio.open_file
+    fs.open_args = ()
+    return True

mindspore/common/generator.py

@@ -0,0 +1,254 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Generator"""
+from mindspore.common.parameter import Parameter
+from mindspore.common import Tensor
+from mindspore.common import dtype as mstype
+from mindspore.ops.operations._inner_ops import Generator as GeneratorOp
+from mindspore.ops.operations._sequence_ops import TensorToScalar
+from mindspore.ops.vm_impl_registry import vm_impl_registry as vm_impl_getters
+from mindspore._c_expression import _random_seeded_generator
+
+
+# pylint: disable=unused-argument
+@vm_impl_getters.register(GeneratorOp)
+def vm_impl_generator(self):
+    """
+    Generate vm_impl function for Generator.
+
+    The default_generator is initialized and called during import.
+    For this reason a vm_impl is required for ut compilation.
+    """
+    def vm_impl(cmd, inputs):
+        return 0
+    return vm_impl
+
+
+STEP = 0
+SEED = 1
+GET_STATE = 2
+SET_STATE = 3
+MANUAL_SEED = 4
+INITIAL_SEED = 5
+
+
+def jit_class(cls):
+    """Make class recognizable in graph mode"""
+    setattr(cls, '__ms_class__', True)
+    return cls
+
+
+@jit_class
+class Generator:
+    """
+    A generator that manages the state of random numbers and provides seed and offset for random functions.
+    When the seed and offset are fixed, the random function generates the same random sequence.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Generator
+        >>> generator = Generator()
+        >>> generator.manual_seed(5)
+        >>> print(generator.initial_seed())
+        5
+        >>> state = generator.get_state()
+        >>> generator.seed()
+        >>> generator.set_state(state)
+        >>> print(generator.initial_seed())
+        5
+    """
+
+    def __init__(self):
+        self._seed = Parameter(Tensor(0, mstype.int64),
+                               name="seed", requires_grad=False)
+        self._offset = Parameter(
+            Tensor(0, mstype.int64), name="offset", requires_grad=False)
+
+        self._generator = GeneratorOp().set_device("CPU")
+        self._to_scalar = TensorToScalar()
+
+    def set_state(self, state):
+        """
+        Sets the generator state.
+
+        Args:
+            state (tensor): target state of the generator.
+        """
+        self._generator(SET_STATE, (self._seed, self._offset, state))
+
+    def get_state(self):
+        """
+        Get the generator state.
+
+        Returns:
+            Tensor, generator state.
+        """
+        return self._generator(GET_STATE, (self._seed, self._offset))[2]
+
+    def seed(self):  # pylint: disable=redefined-outer-name
+        """
+        Seed generator with random number.
+
+        Returns:
+            Randomly generated seeds, the type is int.
+        """
+        current_seed = self._generator(
+            SEED, (self._seed, self._offset))[0]
+        return self._to_scalar(current_seed)
+
+    def manual_seed(self, seed):  # pylint: disable=redefined-outer-name
+        """
+        Set the generator seed.
+
+        Args:
+            seed (int): Set the generator seed.
+
+        Returns:
+            Generator, the generator instance.
+        """
+        if not isinstance(seed, int):
+            raise TypeError("Seed must be an integer.")
+        seed = Tensor(seed, mstype.int64)
+        self._generator(MANUAL_SEED, (self._seed, self._offset, seed))
+        return self
+
+    def initial_seed(self):
+        """
+        Return the initial seed of generator.
+
+        Returns:
+            The initial seed of generator.
+        """
+        current_seed = self._generator(
+            INITIAL_SEED, (self._seed, self._offset))[0]
+        return self._to_scalar(current_seed)
+
+
+    def _step(self, step):
+        """
+        Return current seed and offset, and update offset for the next call.
+
+        Args:
+            step (Tensor): Update offset by step.
+
+        Returns:
+            Current seed and offset.
+        """
+        return self._generator(STEP, (self._seed, self._offset, step,))[:2]
+
+
+default_generator = _random_seeded_generator()
+
+
+def seed():  # pylint: disable=redefined-outer-name
+    """
+    Seed the default generator with random number.
+
+    Returns:
+        Randomly generated seeds, the type is int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import seed
+        >>> print(seed())
+        1663920602
+    """
+    return default_generator.seed()
+
+
+def manual_seed(seed):  # pylint: disable=redefined-outer-name
+    """
+    Set the default generator seed.
+
+    Args:
+        seed (int): Set the default generator seed.
+
+    Returns:
+        Generator, the default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import manual_seed, initial_seed
+        >>> manual_seed(13)
+        >>> print(initial_seed())
+        13
+    """
+    return default_generator.manual_seed(seed)
+
+
+def initial_seed():
+    """
+    Return the initial seed of the default generator.
+
+    Returns:
+        The initial seed of the default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import manual_seed, initial_seed
+        >>> manual_seed(14)
+        >>> print(initial_seed())
+        14
+    """
+    return default_generator.initial_seed()
+
+
+def get_rng_state():
+    """
+    Get the state of the default generator.
+
+    Returns:
+        Tensor, generator state.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import get_rng_state
+        >>> state = get_rng_state()
+    """
+    return default_generator.get_state()
+
+
+def set_rng_state(state):  # pylint: disable=redefined-outer-name
+    """
+    Set the state of the default generator.
+
+    Args:
+        state (Tensor): the target state
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import set_rng_state, get_rng_state
+        >>> state = get_rng_state()
+        >>> set_rng_state(state)
+    """
+    default_generator.set_state(state)
+
+
+__all__ = ["Generator", "default_generator", "seed", "manual_seed", "initial_seed", "set_rng_state", "get_rng_state"]

mindspore/common/hook_handle.py

@@ -14,9 +14,58 @@
 # ============================================================================
 """The removable handle for cell hook function."""
 from __future__ import absolute_import
-
 import weakref
-from mindspore.common.api import _pynative_executor
+from mindspore._c_expression import Tensor as Tensor_
+
+
+class _TensorHookHandle:
+    r"""
+    A handle provides the ability to remote a tensor hook.
+
+    Note:
+        It is only supported in pynative mode and works when registering or removing hook function for tensor
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+
+    def __init__(self):
+        self.id = None
+
+    def remove(self):
+        """
+        Remove the tensor hook function, which corresponds to this '_TensorHookHandle' object.
+
+        Args:
+            None.
+
+        Returns:
+            None.
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> ms.set_context(mode=ms.PYNATIVE_MODE)
+            >>> def hook_fn(grad):
+            ...     return grad * 2
+            ...
+            >>> def hook_test(x, y):
+            ...     z = x * y
+            ...     handle = z.register_hook(hook_fn)
+            ...     z = z * y
+            ...     handle.remove()
+            ...     return z
+            ...
+            >>> ms_grad = ms.grad(hook_test, grad_position=(0,1))
+            >>> output = ms_grad(Tensor(1, ms.float32), Tensor(2, ms.float32))
+            >>> print(output)
+            (Tensor(shape=[], dtype=Float32, value=4), Tensor(shape=[], dtype=Float32, value=4))
+        """
+        if self.id is not None:
+            Tensor_.remove_hook(self.id)
 
 
 class HookHandle:
@@ -28,27 +77,19 @@ class HookHandle:
         It is only supported in pynative mode and works when registering or removing hook function for Cell object.
 
     Args:
-        hook_cell (Cell): The Cell object with hook function registered on. Default value: None.
-        hook_key (int): The key of cell hook function in dict. It is generated during cell hook function registration.
-                        Default value: -1.
-        hook_type (str): The type of cell hook function: '_forward_pre_hook', '_forward_hook' or '_cell_backward_hook'.
-                         Default value: "".
+        hook_dict (Dict): The hook object with hook function registered on. Default value: None.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
-    def __init__(self, hook_cell=None, hook_key=-1, hook_type=""):
-        if hook_cell is not None:
-            self._hook_cell = weakref.ref(hook_cell)
-        else:
-            self._hook_cell = hook_cell
-        self._hook_key = hook_key
-        self._hook_type = hook_type
-
-    def __del__(self):
-        self._hook_cell = None
-        self._hook_key = None
-        self._hook_type = None
+    unique_id = 0
+
+    def __init__(self, hook_dict=None):
+        self.hook_dict_ref = None
+        if hook_dict is not None:
+            self.hook_dict_ref = weakref.ref(hook_dict)
+            self.handle_id = HookHandle.unique_id
+            HookHandle.unique_id += 1
 
     def remove(self):
         """
@@ -72,7 +113,7 @@ class HookHandle:
             >>> from mindspore import Tensor
             >>> from mindspore.ops import GradOperation
             >>> ms.set_context(mode=ms.PYNATIVE_MODE)
-            >>> def forward_pre_hook_fn(cell_id, inputs):
+            >>> def forward_pre_hook_fn(cell, inputs):
             ...     print("forward inputs: ", inputs)
             ...
             >>> class Net(nn.Cell):
@@ -96,13 +137,7 @@ class HookHandle:
             (Tensor(shape=[1], dtype=Float32, value= [ 2.00000000e+00]), Tensor(shape=[1], dtype=Float32,
             value= [ 2.00000000e+00]))
         """
-        if self._hook_cell is not None:
-            hook_cell = self._hook_cell()
-            if self._hook_type == "_forward_pre_hook" and self._hook_key in hook_cell._forward_pre_hook:
-                del hook_cell._forward_pre_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
-            elif self._hook_type == "_forward_hook" and self._hook_key in hook_cell._forward_hook:
-                del hook_cell._forward_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
-            elif self._hook_type == "_cell_backward_hook":
-                hook_cell._cell_backward_hook.remove_backward_hook(self._hook_key)
+        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:
+                del hook_dict[self.handle_id]

mindspore/common/initializer.py

@@ -37,7 +37,7 @@ class Initializer:
         Initializers are intended to be used for delayed initialization in parallel mode rather than Tensor
         initialization. If you have to use Initializers to create a Tensor, :func:`mindspore.Tensor.init_data` should be
         followed in most of the cases. For more information, please refer to `mindspore.Tensor.init_data
-        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
+        <https://www.mindspore.cn/docs/en/master/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
         mindspore-tensor-init-data>`_ .
 
     Args: