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

mindspore/mindrecord/tools/cifar10.py

@@ -15,24 +15,72 @@
 """
 Cifar10 reader class.
 """
-import builtins
+import hashlib
 import io
+import os
 import pickle
 import re
-import os
 import numpy as np
 
+from mindspore import log as logger
 from ..shardutils import check_filename
 
 __all__ = ['Cifar10']
 
-safe_builtins = {
-    'range',
-    'complex',
-    'set',
-    'frozenset',
-    'slice',
-}
+
+class CifarMD5Validator:
+    '''
+    MD5 check for cifar10-batch-py files
+    '''
+    def __init__(self):
+        self.md5_map = {'data_batch_1': 'c99cafc152244af753f735de768cd75f',
+                        'data_batch_2': 'd4bba439e000b95fd0a9bffe97cbabec',
+                        'data_batch_3': '54ebc095f3ab1f0389bbae665268c751',
+                        'data_batch_4': '634d18415352ddfa80567beed471001a',
+                        'data_batch_5': '482c414d41f54cd18b22e5b47cb7c3cb',
+                        'test_batch': '40351d587109b95175f43aff81a1287e'}
+
+    def calculate_md5(self, file_path):
+        """
+        Calculate MD5 hash of a file.
+
+        Args:
+            file_path (str): Path to the file to calculate MD5 for.
+
+        Returns:
+            MD5 hash string if successful, None otherwise.
+        """
+        try:
+            with open(file_path, 'rb') as f:
+                file_hash = hashlib.md5()
+                chunk = f.read(8192)
+                while chunk:
+                    file_hash.update(chunk)
+                    chunk = f.read(8192)
+            return file_hash.hexdigest()
+        except (IOError, OSError):
+            return None
+
+    def check(self, file_path, file_name):
+        """
+        Check if the file's MD5 matches the expected value.
+
+        Args:
+            file_path (str): Path to the file to check.
+            file_name (str): Key in md5_map to identify the expected MD5.
+
+        Returns:
+            True if MD5 matches, False otherwise (including if file doesn't exist).
+
+        Raises:
+            KeyError: If file_name is not found in md5_map.
+        """
+        expected_md5 = self.md5_map.get(file_name)
+        actual_md5 = self.calculate_md5(os.path.join(file_path, file_name))
+
+        if actual_md5 is None or expected_md5 is None or actual_md5 != expected_md5:
+            logger.warning(f"The MD5 value of {file_name} does not match the official CIFAR10 file."
+                           "This file may pose a security risk.")
 
 
 class RestrictedUnpickler(pickle.Unpickler):
@@ -44,8 +92,6 @@ class RestrictedUnpickler(pickle.Unpickler):
     """
     def find_class(self, module, name):
         # Only allow safe classes from builtins and numpy
-        if module == "builtins" and name in safe_builtins:
-            return getattr(builtins, name)
         if module == "numpy.core.multiarray" and name == "_reconstruct":
             return getattr(np.core.multiarray, name)
         if module == "numpy":
@@ -89,6 +135,7 @@ class Cifar10:
         self.one_hot = one_hot
         self.images = None
         self.labels = None
+        self.validator = CifarMD5Validator()
 
     def load_data(self):
         """
@@ -104,12 +151,14 @@ class Cifar10:
         for file in files:
             if re.match("data_batch_*", file):
                 real_file_path = os.path.realpath(self.path)
+                self.validator.check(real_file_path, file)
                 with open(os.path.join(real_file_path, file), 'rb') as f: # load train data
                     dic = restricted_loads(f.read())
                     images = np.r_[images, dic[b"data"].reshape([-1, 3, 32, 32])]
                     labels.append(dic[b"labels"])
             elif re.match("test_batch", file):                       # load test data
                 real_file_path = os.path.realpath(self.path)
+                self.validator.check(real_file_path, file)
                 with open(os.path.join(real_file_path, file), 'rb') as f:
                     dic = restricted_loads(f.read())
                     test_images = np.array(dic[b"data"].reshape([-1, 3, 32, 32]))

mindspore/mindrecord/tools/cifar10_to_mr.py

@@ -49,6 +49,11 @@ class Cifar10ToMR:
         >>> mindrecord_file = "/path/to/mindrecord/file"
         >>> cifar10_to_mr = Cifar10ToMR(cifar10_dir, mindrecord_file)
         >>> cifar10_to_mr.transform()
+
+    .. warning::
+        Cifar10ToMR.transform() uses `pickle` module implicitly, which is known to be insecure.
+        It is possible to construct malicious pickle data which will execute arbitrary code during unpickling.
+        Never load data that could have come from an untrusted source, or that could have been tampered with.
     """
 
     def __init__(self, source, destination):

mindspore/mint/__init__.py

@@ -33,7 +33,7 @@ from mindspore.ops.function.array_func import zeros_like_ext as zeros_like
 from mindspore.ops.function.array_func import unique_ext as unique
 from mindspore.ops.function.array_func import chunk_ext as chunk
 from mindspore.ops.functional_overload import empty
-from mindspore.ops.function.array_func import empty_like
+from mindspore.ops.functional_overload import empty_like
 from mindspore.ops.function.math_func import isclose
 from mindspore.ops.auto_generate import abs
 from mindspore.ops.auto_generate import clone
@@ -63,7 +63,7 @@ from mindspore.ops.auto_generate import stack_ext as stack
 # 7
 from mindspore.ops.function.array_func import unsqueeze
 # 8
-from mindspore.ops.auto_generate import transpose_ext as transpose
+from mindspore.ops.auto_generate import transpose_ext_view as transpose
 from mindspore.ops.auto_generate import batch_norm_elemt
 from mindspore.ops.auto_generate import batch_norm_gather_stats_with_counts
 from mindspore.ops.auto_generate import batch_norm_stats
@@ -291,7 +291,7 @@ from mindspore.ops.function.nn_func import softmax_ext
 # 118
 
 # 119
-
+from mindspore.ops.functional_overload import any
 # 120
 from mindspore.ops.auto_generate import isneginf_ext as isneginf
 # 121
@@ -364,7 +364,7 @@ from mindspore.ops.function.array_func import scatter_add_ext as scatter_add
 # 289
 from mindspore.ops.auto_generate import sign
 
-from mindspore.ops.auto_generate import select_ext as select
+from mindspore.ops.auto_generate import select_ext_view as select
 
 # 301
 from mindspore.ops.function.math_func import tan
@@ -478,7 +478,7 @@ from mindspore.ops.auto_generate import log2_ext as log2
 from mindspore.ops.function.math_func import isnan_ext as isnan
 
 # 916
-from mindspore.ops.auto_generate import index_add_ext as index_add
+from mindspore.ops.functional_overload import index_add
 
 # 1007
 from mindspore.ops.auto_generate import t_ext as t
@@ -490,46 +490,6 @@ from mindspore.ops.auto_generate.gen_ops_prim import equal_ext_op
 from mindspore.ops.function.array_func import unbind_ext as unbind
 
 
-def any(input, dim=None, keepdim=False):
-    r"""
-    Tests if any element in `input` evaluates to `True` along the given axes.
-
-    Args:
-        input (Tensor): The input tensor.
-        dim (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce. If ``None`` ,
-                all dimensions are reduced. Default ``None`` .
-        keepdim (bool, optional): Whether the output tensor has dim retained or not. Default ``False`` .
-
-    Returns:
-        Tensor
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> input = mindspore.tensor([[True, False], [True, True]])
-        >>>
-        >>> # case 1:  By default, mindspore.mint.any tests along all the axes.
-        >>> mindspore.mint.any(input)
-        Tensor(shape=[], dtype=Bool, value= True)
-        >>>
-        >>> # case 2: Reduces a dimension along dim 1, with keepdim False.
-        >>> mindspore.mint.any(input, dim=1)
-        Tensor(shape=[2], dtype=Bool, value= [ True,  True])
-        >>>
-        >>> # case 3: Reduces a dimension along dim (0, 1), with keepdim False.
-        >>> mindspore.mint.any(input, dim=(0,1))
-        Tensor(shape=[], dtype=Bool, value= True)
-        >>>
-        >>> # case 4: Reduces a dimension along dim [0, 1], with keepdim True.
-        >>> mindspore.mint.any(input, dim=[0,1], keepdim=True)
-        Tensor(shape=[1, 1], dtype=Bool, value=
-        [[ True]])
-    """
-    return ops.functional.any(input, dim, keepdim)
-
-
 def all(input, dim=None, keepdim=False):
     r"""
     all(input) -> Tensor
@@ -717,7 +677,7 @@ def cummax(input, dim):
         \end{array}
 
     .. note::
-        O2 mode is not supported in Ascend.
+        GE backend is not supported in Ascend.
 
     Args:
         input (Tensor): The input Tensor. Rank of `input` must be greater than 0.

mindspore/mint/distributed/__init__.py

@@ -24,6 +24,7 @@ Please see the `msrun start up
 for more details.
 """
 from __future__ import absolute_import
+from mindspore.mint.distributed.distributed import TCPStore
 from mindspore.mint.distributed.distributed import (
     init_process_group,
     destroy_process_group,

mindspore/mint/distributed/distributed.py

@@ -70,6 +70,7 @@ from mindspore.ops.auto_generate.gen_ops_prim import (
     dist_comm_barrier_op,
     dist_comm_batch_isend_irecv_op,
 )
+from mindspore._c_expression import TCPStoreClient, GroupOptions
 
 _pickler = pickle.Pickler
 _unpickler = pickle.Unpickler
@@ -137,6 +138,193 @@ def _tensor_to_object(tensor, tensor_size):
     return restricted_loads(buf)
 
 
+class TCPStore:
+    """
+    A TCP-based distributed key-value store implementation.
+
+    Note:
+        - The function is implemented by CPU and does not involve any hardware operations related to Ascend.
+        - Currently, all parameters provided by the TCPStore class constructor are not supported.
+          The master node and port number are uniformly specified by the MindSpore framework.
+          The following parameters are provided, currently not supported and settings are invalid.
+        - The current TcpStore function is limited and only supports scenarios where the key is
+          less than 4k and the value is less than 1G. Complex scenarios are to be supported.
+        - The timeout interval for message sending and receiving in the TcpStore function is controlled by
+          the `MS_RECEIVE_MSG_TIMEOUT` environment variable, in seconds, with a default value of ``15``.
+          If a timeout occurs, the user needs to increase the configuration value.
+
+    Args:
+        host_name (str, invalid, optional): The hostname or IP Address the server store should run on.
+            Default is ``None``.
+        port (int, invalid, optional): The port on which the server store should listen for incoming requests.
+            Default is ``None``.
+        world_size (int, invalid, optional): The total number of store users (number of clients + 1 for the server).
+            Default is ``None`` (``None`` indicates a non-fixed number of store users).
+        is_master (bool, invalid, optional): True when initializing the server store and False for client stores.
+            Default is ``False``.
+        timeout (timedelta, invalid, optional): Timeout used by the store during initialization, Unit: seconds.
+            Default is ``300``.
+        wait_for_workers (bool, invalid, optional): Whether to wait for all the workers to connect with the server
+            store. This is only applicable when `world_size` is a fixed value. Default is ``True``.
+        multi_tenant (bool, invalid, optional): If ``True``, all ``TCPStore`` instances in the current process with
+            the same host/port will use the same underlying ``TCPServer``. Default is ``False``.
+        master_listen_fd (int, invalid, optional): If specified, the underlying ``TCPServer`` will listen on this file
+            descriptor, which must be a socket already bound to ``port``. Useful to avoid port assignment races
+            in some scenarios. Default is ``None`` (meaning the server creates a new socket and attempts to bind it
+            to ``port``).
+        use_libuv (bool, invalid, optional): If True, use libuv for ``TCPServer`` backend. Default is ``True``.
+
+    Returns:
+        TCPStore Object.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For Ascend devices, it is recommended to use the msrun startup method
+            without any third-party or configuration file dependencies.
+            Please see the `msrun start up
+            <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
+            for more details.
+
+        >>> from mindspore.mint.distributed import TCPStore
+        >>> store = TCPStore()
+    """
+
+    def __init__(self, host_name=None, port=None, world_size=None, is_master=False, timeout=300,
+                 wait_for_workers=True, multi_tenant=False, master_listen_fd=None, use_libuv=True):
+        self.instance = TCPStoreClient.get_instance()
+
+
+    def set(self, key, value):
+        """
+        Inserts the key-value pair into the store based on the supplied `key` and
+        `value`. If `key` already exists in the store, it will overwrite the old
+        value with the new supplied `value`.
+
+        Args:
+            key (str): The key to be added to the store.
+            value (Union[bytes, str]): The value associated with `key` to be added to the store.
+
+        Raises:
+            TypeError: If `key` is not string.
+            TypeError: If `value` is not string or bytes.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            .. note::
+                Before running the following examples, you need to configure the communication environment variables.
+
+                For Ascend devices, it is recommended to use the msrun startup method
+                without any third-party or configuration file dependencies.
+                Please see the `msrun start up
+                <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
+                for more details.
+
+            >>> from mindspore.mint.distributed import TCPStore
+            >>> store = TCPStore()
+            >>> store.set("first_key", "first_value")
+        """
+        if not isinstance(key, str):
+            raise TypeError(
+                "For 'TCPStore.set', the argument 'key' must be type of string, "
+                "but got 'key' type : {}.".format(type(key))
+            )
+        if not isinstance(value, (str, bytes)):
+            raise TypeError(
+                "For 'TCPStore.set', the argument 'value' must be type of string or bytes, "
+                "but got 'value' type : {}.".format(type(value))
+            )
+        return self.instance.set(key, value)
+
+
+    def get(self, key):
+        """
+        Retrieves the value associated with the given `key` in the store. If `key` is not
+        present in the store, the function will return "".
+
+        Args:
+            key (str): The function will return the value associated with this key.
+
+        Returns:
+            bytes, Value associated with `key` if `key` is in the store.
+
+        Raises:
+            TypeError: If `key` is not string.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            .. note::
+                Before running the following examples, you need to configure the communication environment variables.
+
+                For Ascend devices, it is recommended to use the msrun startup method
+                without any third-party or configuration file dependencies.
+                Please see the `msrun start up
+                <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
+                for more details.
+
+            >>> from mindspore.mint.distributed import TCPStore
+            >>> store = TCPStore()
+            >>> store.set("first_key", "first_value")
+            >>> data = store.get("first_key")
+            >>> print(data)
+        """
+        if not isinstance(key, str):
+            raise TypeError(
+                "For 'TCPStore.get', the argument 'key' must be type of string, "
+                "but got 'key' type : {}.".format(type(key))
+            )
+        byte_data = self.instance.get(key)
+        return byte_data
+
+
+    def delete_key(self, key):
+        """
+        Deletes the key-value pair associated with `key` from the store.
+
+        Args:
+            key (str): The key to be deleted from the store.
+
+        Returns:
+            bool, ``True`` if `key` was deleted, otherwise ``False``.
+
+        Raises:
+            TypeError: If `key` is not string.
+
+        Supported Platforms:
+            ``CPU``
+
+        Examples:
+            .. note::
+                Before running the following examples, you need to configure the communication environment variables.
+
+                For Ascend devices, it is recommended to use the msrun startup method
+                without any third-party or configuration file dependencies.
+                Please see the `msrun start up
+                <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
+                for more details.
+
+            >>> from mindspore.mint.distributed import TCPStore
+            >>> store = TCPStore()
+            >>> store.set("first_key", "first_value")
+            >>> # This should return true
+            >>> store.delete_key("first_key")
+        """
+        if not isinstance(key, str):
+            raise TypeError(
+                "For 'TCPStore.delete_key', the argument 'key' must be type of string, "
+                "but got 'key' type : {}.".format(type(key))
+            )
+        return self.instance.delete_key(key)
+
+
 def is_available():
     """
     Checks if distributed module is available.
@@ -470,7 +658,19 @@ def new_group(ranks=None,
             when backend is ``"hccl"`` will use Huawei Collective Communication Library(HCCL).
             when  backend is ``"mccl"`` will use MindSpore Collective Communication Library(MCCL).
             If ``None``, which means ``"hccl"`` in Ascend. Default is ``None``.
-        pg_options (str, invalid): Currently it is a reserved parameter.
+        pg_options (GroupOptions, optional): Additional communication group configuration parameters.
+            The backend will automatically select supported parameters and apply them during group
+            initialization. i.e. for the ``HCCL`` backend, ``hccl_config`` can be specified so that
+            group initialization configurations can be applied. Default is ``None``.
+
+            `GroupOptions` is defined as a class that can be instantiated as a python object.
+
+            .. code-block::
+
+                GroupOptions {
+                    hccl_config(dict)
+                }
+
         use_local_synchronization (bool, invalid): Currently it is a reserved parameter.
         group_desc (str, invalid): Currently it is a reserved parameter.
 
@@ -511,8 +711,11 @@ def new_group(ranks=None,
     if not isinstance(backend, str) or backend not in ("hccl", "mccl"):
         raise TypeError(f"the input backend must be hccl or mccl, but got {backend}")
     group = backend + "_" + str(len(ranks)) + "_" + hashlib.sha1(bytes("_".join(map(str, ranks)), "utf-8")).hexdigest()
+    if pg_options is not None:
+        if not isinstance(pg_options, GroupOptions):
+            raise TypeError("pg_options must be type GroupOptions, but got {}".format(type(pg_options)))
     try:
-        create_group(group, ranks)
+        create_group(group, ranks, pg_options)
     except RuntimeError as e:
         logger.warning(e)
         group = ""
@@ -813,7 +1016,7 @@ def all_reduce(tensor, op=ReduceOp.SUM, group=None, async_op=False):
         RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         .. note::
@@ -1589,7 +1792,7 @@ def barrier(group=None, async_op=False, device_ids=None):
         RuntimeError: If backend is invalid, or distributed initialization fails.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         .. note::
@@ -1647,7 +1850,7 @@ def send(tensor, dst=0, group=None, tag=0):
         ValueError: If the `dst` process rank id is same as the current process.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         .. note::
@@ -1725,7 +1928,7 @@ def recv(tensor, src=0, group=None, tag=0):
         ValueError: If the rank ID of the process is greater than the rank size of the communication group.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         .. note::
@@ -2018,10 +2221,10 @@ def all_to_all(output_tensor_list, input_tensor_list, group=None, async_op=False
     recv_shape_list = []
 
     for tensor in input_tensor_list:
-        send_numel_list.append(tensor.size)
+        send_numel_list.append(tensor.numel())
         send_flatten_tensor.append(tensor.reshape(-1))
     for tensor in output_tensor_list:
-        recv_numel_list.append(tensor.size)
+        recv_numel_list.append(tensor.numel())
         recv_shape_list.append(tensor.shape)
 
     send_flatten_tensor = cat(send_flatten_tensor)
@@ -2810,7 +3013,7 @@ def broadcast_object_list(object_list, src=0, group=None, device=None):
         offset = 0
         for i, item in enumerate(object_size):
             obj_size = item
-            obj_view = object_tensor[offset : offset + obj_size]
+            obj_view = object_tensor[offset: offset + obj_size]
             offset += obj_size
             object_list[i] = _tensor_to_object(obj_view, obj_size)
 

mindspore/mint/nn/__init__.py

@@ -1189,7 +1189,7 @@ class PixelShuffle(Cell):
         >>> pixel_shuffle = mint.nn.PixelShuffle(3)
         >>> input = mint.randn(1, 9, 4, 4)
         >>> output = pixel_shuffle(input)
-        >>> print(output.shape())
+        >>> print(output.shape)
             [1, 1, 12, 12]
     """
 

mindspore/mint/nn/functional.py

@@ -67,7 +67,7 @@ from mindspore.ops.auto_generate import prelu
 # 20
 
 # 21
-from mindspore.ops.function.nn_func import conv3d_ext as conv3d
+from mindspore.ops.functional_overload import conv3d
 # 22
 
 # 23
@@ -118,7 +118,8 @@ from mindspore.ops.auto_generate import soft_margin_loss
 # 45
 
 # 46
-from mindspore.ops.functional import silu
+from mindspore.ops.auto_generate import silu as silu_func
+from mindspore.ops.auto_generate import inplace_silu
 # 47
 
 # 48
@@ -283,6 +284,52 @@ from mindspore.ops.functional import adaptive_avg_pool2d_ext as adaptive_avg_poo
 from mindspore.ops.function.nn_func import cross_entropy_ext as cross_entropy
 from mindspore.ops.function.nn_func import nll_loss_ext as nll_loss
 
+def silu(input, inplace=False):
+    r"""
+    Computes Sigmoid Linear Unit of input element-wise. The SiLU function is defined as:
+
+    .. math::
+
+        \text{SiLU}(x) = x * \sigma(x),
+
+    where :math:`x` is an element of the input, :math:`\sigma(x)` is Sigmoid function.
+
+    .. math::
+
+        \text{sigma}(x_i) = \frac{1}{1 + \exp(-x_i)},
+
+    SiLU Function Graph:
+
+    .. image:: ../images/SiLU.png
+        :align: center
+
+    Args:
+        input (Tensor): `input` is :math:`x` in the preceding formula. Input with the data type
+            float16 or float32.
+        inplace (bool, optional): If it is ``True``, enable the in place update function. Default value: ``False``.
+
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is neither float16 nor float32.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> output = mint.nn.functional.silu(input, inplace=False)
+        >>> print(output)
+        [-0.269  1.762  -0.1423  1.762  -0.269]
+    """
+    if inplace:
+        return inplace_silu(input)
+    return silu_func(input)
+
 
 def elu(input, alpha=1.0, inplace=False):
     r"""
@@ -511,7 +558,10 @@ def binary_cross_entropy(input, target, weight=None, reduction='mean'):
         \end{cases}
 
     .. warning::
-        - The value of `input` must range from `0` to `l`.
+        The value of `input` must range from `0` to `l`.
+
+    .. note::
+        Currently, when the platform is Ascend, all gradient calculations are performed on NPU.
 
     Args:
         input (Tensor): The predictive value whose data type must be float16 or float32.
@@ -955,9 +1005,6 @@ def threshold(input, threshold, value, inplace=False):  # pylint: disable=W0621
         \text{value}, &\text{ otherwise }
         \end{cases}
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input Tensor.
         threshold (Union[int, float]): The value of the threshold.