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

mindspore/mint/__init__.py

@@ -486,6 +486,11 @@ from mindspore.ops.auto_generate.pyboost_inner_prim import squeeze_impl
 from mindspore.ops.auto_generate.gen_ops_prim import equal_ext_op
 
 
+# 1101
+from mindspore.ops.functional_overload import real
+# 1102
+from mindspore.ops.functional_overload import imag
+
 # 1023
 from mindspore.ops.function.array_func import unbind_ext as unbind
 
@@ -609,6 +614,9 @@ def cat(tensors, dim=0):
 
         (x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)
 
+    .. warning::
+        Input tensor of inconsistent types are not supported in Graph Mode under Dynamic Shape.
+
     Args:
         tensors (Union[tuple, list]): A tuple or a list of input tensors.
             Suppose there are two tensors in this tuple or list, namely t1 and t2.
@@ -620,7 +628,6 @@ def cat(tensors, dim=0):
 
     Returns:
         Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
-        The data type is the same with `tensors`.
 
     Raises:
         TypeError: If `dim` is not an int.
@@ -658,7 +665,7 @@ def concat(tensors, dim=0):
     Alias for :func:`mindspore.mint.cat`.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
+        Input tensor of inconsistent types are not supported in Graph Mode under Dynamic Shape.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -744,9 +751,6 @@ def equal(input, other):
     Note:
         `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The first input.
         other (Tensor): The second input.
@@ -1323,8 +1327,6 @@ def swapaxes(input, axis0, axis1):
     Alias for :func:`mindspore.mint.transpose` . The `input` corresponds to the `input` in the reference interface,
     and the parameters `axis0` and `axis1` correspond to `dim0` and `dim1` in the reference interface respectively.
 
-    For more details, see :func:`mindspore.mint.transpose` .
-
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
@@ -1438,8 +1440,6 @@ def fix(input):
     """
     Alias for :func:`mindspore.mint.trunc` .
 
-    For more details, see :func:`mindspore.mint.trunc` .
-
     Supported Platforms:
         ``Ascend``
     """
@@ -1535,7 +1535,7 @@ def cdist(x1, x2, p=2.0, compute_mode='use_mm_for_euclid_dist_if_necessary'):
         x2 (Tensor): Input tensor of shape :math:`(B, R, M)`, has the same dtype as `x1`.
         p (float, optional): P value for the p-norm distance to calculate between each
             vector pair, P >= 0. Default: ``2.0`` .
-        compute_mode (string, optional): Specify the cumpute mode. Setting this parameter currently has no effect.
+        compute_mode (str, optional): Specify the cumpute mode. Setting this parameter currently has no effect.
             Default: ``'use_mm_for_euclid_dist_if_necessary'`` .
 
     Returns:
@@ -2061,6 +2061,11 @@ __all__ = [
 
     # 1100
     'diff',
+
+    # 1101
+    'real',
+    # 1102
+    'imag',
 ]
 
 __all__.extend(functional.__all__)

mindspore/mint/distributed/distributed.py

@@ -18,13 +18,16 @@ import hashlib
 import builtins
 import io
 import pickle
+from datetime import timedelta
 import numpy as np
 from mindspore import log as logger
 from mindspore.common import dtype as mstype
+from mindspore._checkparam import args_type_check
 from mindspore.ops import ReduceOp, cat
 from mindspore.common.tensor import Tensor
 from mindspore._c_expression import TensorPy as Tensor_
 from mindspore.ops.primitive import _primexpr
+from mindspore.common.api import _pynative_executor
 from mindspore.communication._comm_helper import (
     _destroy_group_helper,
     _get_rank_helper,
@@ -33,10 +36,11 @@ from mindspore.communication._comm_helper import (
     _get_group_ranks,
     _is_available,
     _is_initialized,
+    _ExistingGroup,
 )
+from mindspore.communication.management import _init_without_sched
 from mindspore.communication import (
     init,
-    release,
     get_group_size,
     get_world_rank_from_group_rank,
     create_group,
@@ -72,7 +76,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
+from mindspore._c_expression import TCPStoreClient, GroupOptions, _finalize_collective
 
 _pickler = pickle.Pickler
 _unpickler = pickle.Unpickler
@@ -146,28 +150,26 @@ class TCPStore:
 
     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
+        - Currently, all parameters provided by the TCPStore class constructor are not supported
+          except for `host_name`, `port`, `world_size`, `is_master`, `timeout` and `wait_for_workers`,
+          which are reserved parameters and invalid settings.
+        - 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.
+        host_name (str): The hostname or IP Address the server store should run on.
+            Currently only supports user input IP addresses.
+        port (int): The port on which the server store should listen for incoming requests.
+        world_size (int, optional): The total number of store users (number of clients + 1 for the server).
+            Default is ``None``, indicates a non-fixed number of store users. This parameter is
+            only valid for the server.
+        is_master (bool, 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``.
+        timeout (timedelta, optional): Timeout used by the store during initialization. Default is
+            ``timedelta(seconds=300)``.
+        wait_for_workers (bool, 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``. This
+            parameter is only valid for the server.
         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
@@ -193,12 +195,106 @@ class TCPStore:
             for more details.
 
         >>> from mindspore.mint.distributed import TCPStore
-        >>> store = TCPStore()
+        >>> store = TCPStore("127.0.0.1", 1234)
     """
 
-    def __init__(self, host_name=None, port=None, world_size=None, is_master=False, timeout=300,
+    def __init__(self, host_name, port, world_size=None, is_master=False, timeout=timedelta(seconds=300),
                  wait_for_workers=True, multi_tenant=False, master_listen_fd=None, use_libuv=True):
-        self.instance = TCPStoreClient.get_instance()
+        if not isinstance(host_name, str):
+            raise TypeError(
+                "For 'TCPStore', the argument 'host_name' must be type of string, "
+                "but got 'host_name' type : {}.".format(type(host_name))
+            )
+        if not isinstance(port, int):
+            raise TypeError(
+                "For 'TCPStore', the argument 'port' must be type of int, "
+                "but got 'port' type : {}.".format(type(port))
+            )
+        if not isinstance(is_master, bool):
+            raise TypeError(
+                "For 'TCPStore', the argument 'is_master' must be type of bool, "
+                "but got 'is_master' type : {}.".format(type(is_master))
+            )
+        if not isinstance(timeout, timedelta):
+            raise TypeError(
+                "For 'TCPStore', the argument 'timeout' must be type of timedelta, "
+                "but got 'timeout' type : {}.".format(type(timeout))
+            )
+        if not isinstance(wait_for_workers, bool):
+            raise TypeError(
+                "For 'TCPStore', the argument 'wait_for_workers' must be type of bool, "
+                "but got 'wait_for_workers' type : {}.".format(type(wait_for_workers))
+            )
+        if world_size is None:
+            world_size = 1
+        if not isinstance(world_size, int):
+            raise TypeError(
+                "For 'TCPStore', the argument 'world_size' must be type of int, "
+                "but got 'world_size' type : {}.".format(type(world_size))
+            )
+        if port < 0 or port > 65535:
+            raise ValueError(
+                "For 'TCPStore', the argument 'port' must be legal, "
+                f"but got {port}."
+            )
+        if world_size <= 0:
+            raise ValueError(
+                "For 'TCPStore', the argument 'world_size' must be legal, "
+                f"but got {world_size}."
+            )
+        timeout_ms = int(timeout.total_seconds() * 1000)
+        self.instance = TCPStoreClient(host_name, port, is_master, timeout_ms, world_size, wait_for_workers)
+        self.host = host_name
+        self.port = port
+
+
+    def add(self, key, amount):
+        """
+        When the `add` function is called for the first time with a given key, it creates a counter in
+        the storage corresponding to that key, with the initial value set to `amount`. Subsequent calls
+        to `add` with the same key increment the counter by amount.
+
+        Args:
+            key (str): The key whose counter value will be incremented.
+            amount (int): The amount by which the counter will be incremented.
+
+        Returns:
+            int, value of counter with `key`.
+
+        Raises:
+            TypeError: If `key` is not string.
+            TypeError: If `amount` is not int.
+            RuntimeError: If the `add` and `set` pass the same `key` and the `value` passed by `set` cannot
+                be correctly converted to a numerical value, calling `add` will result in an error.
+
+        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("127.0.0.1", 1234)
+            >>> store.add("first_key", 1)
+        """
+        if not isinstance(key, str):
+            raise TypeError(
+                "For 'TCPStore.add', the argument 'key' must be type of string, "
+                "but got 'key' type : {}.".format(type(key))
+            )
+        if not isinstance(amount, int):
+            raise TypeError(
+                "For 'TCPStore.add', the argument 'amount' must be type of string or int, "
+                "but got 'amount' type : {}.".format(type(amount))
+            )
+        return self.instance.add(key, amount)
 
 
     def set(self, key, value):
@@ -229,7 +325,7 @@ class TCPStore:
                 for more details.
 
             >>> from mindspore.mint.distributed import TCPStore
-            >>> store = TCPStore()
+            >>> store = TCPStore("127.0.0.1", 1234)
             >>> store.set("first_key", "first_value")
         """
         if not isinstance(key, str):
@@ -247,8 +343,9 @@ class TCPStore:
 
     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 "".
+        Retrieves the value associated with the given `key` in the store. If the `key` does not exist
+        in the storage, this function will wait for the `timeout` set by the class initialization and then
+        throw an exception.
 
         Args:
             key (str): The function will return the value associated with this key.
@@ -258,6 +355,7 @@ class TCPStore:
 
         Raises:
             TypeError: If `key` is not string.
+            RuntimeError: If `get` runs out of time.
 
         Supported Platforms:
             ``Ascend``
@@ -273,7 +371,7 @@ class TCPStore:
                 for more details.
 
             >>> from mindspore.mint.distributed import TCPStore
-            >>> store = TCPStore()
+            >>> store = TCPStore("127.0.0.1", 1234)
             >>> store.set("first_key", "first_value")
             >>> data = store.get("first_key")
             >>> print(data)
@@ -301,7 +399,7 @@ class TCPStore:
             TypeError: If `key` is not string.
 
         Supported Platforms:
-            ``CPU``
+            ``Ascend``
 
         Examples:
             .. note::
@@ -314,7 +412,7 @@ class TCPStore:
                 for more details.
 
             >>> from mindspore.mint.distributed import TCPStore
-            >>> store = TCPStore()
+            >>> store = TCPStore("127.0.0.1", 1234)
             >>> store.set("first_key", "first_value")
             >>> # This should return true
             >>> store.delete_key("first_key")
@@ -389,6 +487,7 @@ def is_initialized():
     return _is_initialized()
 
 
+@args_type_check(init_method=str, timeout=timedelta, world_size=int, rank=int, store=TCPStore)
 def init_process_group(backend="hccl",
                        init_method=None,
                        timeout=None,
@@ -406,26 +505,29 @@ def init_process_group(backend="hccl",
         and the instantiation and execution of any operation and net.
 
     Args:
-        backend (str, optional): The backend to ues. default is hccl and now only support hccl.
-        init_method (str, invalid): URL specifying how to init collective communication group. Provides parameters
-            consistent with pytorch, but is not currently support, setting is invalid.
-        timeout (timedelta, invalid): Timeout for API executed. Provides parameters consistent with pytorch, but is not
-            currently support, setting is invalid.
-        world_size (int, optional): Number of the processes participating in the job.
-        rank (int, invalid): Rank of the current process. Provides parameters consistent with pytorch, but is not
-            currently support, setting is invalid.
-        store (Store, invalid): Key/Value store accessible to all workers, used to exchange connection/address
-            information. Provides parameters consistent with pytorch, but is not currently support,
-            setting is invalid.
+        backend (str, optional): The backend to ues. Default is ``"hccl"`` and now only support hccl.
+        init_method (str, optional): URL specifying how to init collective communication group. Default is ``None``.
+        timeout (timedelta, optional): Timeout for API executed. Default is ``None``. Currently, this parameter is
+            only supported for host-side cluster network configuration using `init_method` or `store`.
+        world_size (int, optional): Number of the processes participating in the job. Default is ``-1``.
+        rank (int, optional): Rank of the current process. Default is ``-1``.
+        store (Store, optional): An object that stores key/value data, facilitating the exchange of inter-process
+            communication addresses and connection information. Default is ``None``. Currently, only the
+            ``TCPStore`` type is supported.
         pg_options (ProcessGroupOptions, invalid): process group options specifying what additional options need to be
-            passed in during the construction of specific process group. Provides parameters consistent with pytorch,
-            but is not currently support, setting is invalid.
-        device_id (int, invalid): the device id to exeute. Provides parameters consistent with pytorch, but is not
-            currently support, setting is invalid.
+            passed in during the construction of specific process group. The provided parameter is a reserved
+            parameter, and the current setting does not take effect.
+        device_id (int, invalid): the device id to exeute. The provided parameter is a reserved parameter,
+            and the current setting does not take effect.
 
     Raises:
         ValueError: If `backend` is not hccl.
         ValueError: If `world_size` is not equal to -1 or process group number.
+        ValueError: If both `init_method` and `store` are set.
+        ValueError: `world_size` is not correctly set as a positive integer value, when using the initialization
+            method `init_method` or `store`.
+        ValueError: `rank` is not correctly set as a non-negative integer, when using the initialization method
+            `init_method` or `store`.
         RuntimeError: If device target is invalid, or backend is invalid, or distributed initialization fails,
             or the environment variables RANK_ID/MINDSPORE_HCCL_CONFIG_PATH
             have not been exported when backend is HCCL.
@@ -449,25 +551,34 @@ def init_process_group(backend="hccl",
         >>> init_process_group()
         >>> destroy_process_group()
     """
-    if init_method is not None:
-        logger.warning("init_method is ignored, setting is invalid")
-    if timeout is not None:
-        logger.warning("timeout is ignored, setting is invalid")
-    if store is not None:
-        logger.warning("store is ignored, setting is invalid")
     if pg_options is not None:
         logger.warning("pg_options is ignored, setting is invalid")
     if device_id is not None:
         logger.warning("device_id is ignored, setting is invalid")
-    if rank != -1:
-        logger.warning("rank is ignored, setting is invalid")
     if backend != "hccl":
         raise ValueError(
             "Only support hccl now, please setting backend to hccl or using default value"
         )
 
-    # init hccl & create world group
-    init(backend)
+    if init_method is not None and store is not None:
+        raise ValueError(
+            "Only one of init_method and store is supported."
+        )
+    if init_method is not None or store is not None:
+        if world_size <= 0:
+            raise ValueError(
+                "Specified world_size must be a positive integer."
+            )
+        if rank < 0:
+            raise ValueError(
+                "Specified rank must be a non-negative integer."
+            )
+        if timeout is None:
+            timeout = timedelta(seconds=300)
+        timeout_ms = int(timeout.total_seconds() * 1000)
+        _init_without_sched(backend, init_method, timeout_ms, world_size, rank, store)
+    else:
+        init(backend)
 
     if world_size != -1 and world_size != get_group_size():
         raise ValueError(
@@ -515,7 +626,10 @@ def destroy_process_group(group=None):
     """
 
     if group == GlobalComm.WORLD_COMM_GROUP or group is None:
-        release()
+        _pynative_executor.sync()
+        _finalize_collective()
+        _ExistingGroup.ITEMS.clear()
+        _ExistingGroup.GROUP_RANKS.clear()
     elif not isinstance(group, str):
         raise TypeError(
             "For 'destroy_group', the argument 'group' must be type of string or None, "
@@ -673,6 +787,12 @@ def new_group(ranks=None,
                     hccl_config(dict)
                 }
 
+            `hccl_config` currently only supports "hccl_buffer_size" or "hccl_comm".
+
+            - hccl_buffer_size (uint32): specifies the size of the HCCL communication buffer.
+            - hccl_comm (int64): specifies an existing HcclComm pointer. If "hccl_comm" is set,
+              "hccl_buffer_size" will be ignored.
+
         use_local_synchronization (bool, invalid): Currently it is a reserved parameter.
         group_desc (str, invalid): Currently it is a reserved parameter.
 
@@ -1223,9 +1343,9 @@ def all_gather_into_tensor_uneven(output, input, output_split_sizes=None, group=
         >>> ms.set_device(device_target="Ascend")
         >>> init_process_group()
         >>> if get_rank() == 0:
-        >>>     input_tensor = Tensor(np.ones([3, 4]).astype(np.float32))
-        >>> else:
-        >>>     input_tensor = Tensor(np.ones([2, 4]).astype(np.float32))
+        ...     input_tensor = Tensor(np.ones([3, 4]).astype(np.float32))
+        ... else:
+        ...     input_tensor = Tensor(np.ones([2, 4]).astype(np.float32))
         >>> out_tensor = Tensor(np.zeros([5, 4]).astype(np.float32))
         >>> output_split_sizes = [3, 2]
         >>> output = all_gather_into_tensor_uneven(out_tensor, input_tensor, output_split_sizes)
@@ -1357,7 +1477,7 @@ def reduce_scatter_tensor_uneven(output, input, input_split_sizes=None, op=Reduc
 
     Args:
         output(Tensor): the output tensor has the same dtype as `input` with a shape of
-            :math:`(input_split_sizes[rank], *)`, where rank is the local rank id of the device.
+            :math:`(input\_split\_sizes[rank], *)`, where rank is the local rank id of the device.
         input(Tensor): The input tensor to be reduced and scattered, Expected shape :math:`(N, *)`, where `*`
             means any number of additional dimensions. N must equal the sum of `input_split_sizes` across ranks.
         input_split_sizes (list[int], optional): List specifying how to split the first dimension of input tensor.
@@ -1401,9 +1521,9 @@ def reduce_scatter_tensor_uneven(output, input, input_split_sizes=None, op=Reduc
         >>> init_process_group()
         >>> input_tensor = Tensor(np.ones([5, 8]).astype(np.float32))
         >>> if get_rank() == 0:
-        >>>     output_tensor = Tensor(np.ones([2, 8]).astype(np.float32))
-        >>> else:
-        >>>     output_tensor = Tensor(np.ones([3, 8]).astype(np.float32))
+        ...     output_tensor = Tensor(np.ones([2, 8]).astype(np.float32))
+        ... else:
+        ...     output_tensor = Tensor(np.ones([3, 8]).astype(np.float32))
         >>> input_split_sizes = [2, 3]
         >>> output = reduce_scatter_tensor_uneven(output_tensor, input_tensor, input_split_sizes)
         >>> print(output_tensor)

mindspore/mint/nn/__init__.py

@@ -61,6 +61,7 @@ from mindspore.nn.layer import ReLU
 
 # 14
 from mindspore.nn.layer.basic import DropoutExt as Dropout
+from mindspore.nn.layer.basic import Dropout2dExt as Dropout2d
 # 15
 from mindspore.mint.nn.layer.conv import Conv1d, Conv2d, Conv3d, ConvTranspose2d
 # 16
@@ -260,9 +261,6 @@ from mindspore.mint.nn.layer.activation import Threshold
 # 258
 from mindspore.ops.function.nn_func import mse_loss_ext
 
-# 393
-from mindspore.mint.nn.layer.basic import Dropout2d
-
 # 406
 from mindspore.mint.nn.layer.activation import ELU
 
@@ -325,9 +323,6 @@ class NLLLoss(Cell):
         \sum_{n=1}^{N} l_{n}, & \text { if reduction }=\text { 'sum' }
         \end{array}\right.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             If not None, the shape is :math:`(C,)`, data type must be float16 or float32 or bfloat16(only supported by
@@ -696,9 +691,6 @@ class ReLU6(Cell):
     r"""
     Activation function ReLU6.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Refer to :func:`mindspore.mint.nn.functional.relu6` for more details.
 
     ReLU6 Activation Function Graph:
@@ -847,9 +839,6 @@ class SmoothL1Loss(Cell):
 
     Refer to :func:`mindspore.mint.nn.functional.smooth_l1_loss` for more details.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Supported Platforms:
         ``Ascend``
 
@@ -1190,7 +1179,7 @@ class PixelShuffle(Cell):
         >>> input = mint.randn(1, 9, 4, 4)
         >>> output = pixel_shuffle(input)
         >>> print(output.shape)
-            [1, 1, 12, 12]
+            (1, 1, 12, 12)
     """
 
     def __init__(self, upscale_factor):
@@ -1448,9 +1437,6 @@ __all__ = [
 
     # 388
     'AdaptiveMaxPool2d',
-
-    # 393
-    'Dropout2d',
     # 406
     'ELU',
     # 407