mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/communication/management.py

@@ -21,7 +21,7 @@ from mindspore.communication._comm_helper import Backend, _get_rank_helper, _get
     _get_world_rank_from_group_rank_helper, _get_group_rank_from_world_rank_helper, \
     _create_group_helper, _destroy_group_helper, HCCL_WORLD_COMM_GROUP, NCCL_WORLD_COMM_GROUP, \
     MCCL_WORLD_COMM_GROUP, DEVICE_TO_BACKEND, _get_local_rank_helper, _get_local_size_helper, GlobalComm, \
-    _check_mpi_envs, _set_elegant_exit_handle, _get_group_ranks, _get_comm_name_helper
+    _check_mpi_envs, _set_elegant_exit_handle, _get_group_ranks, _get_comm_name_helper, _comm_switch_nic_helper
 from mindspore._c_expression import init_hccl, finalize_hccl, init_cluster, MSContext, ms_ctx_param
 from mindspore.hal.device import is_initialized
 
@@ -116,7 +116,7 @@ def _check_hccl():
     except Exception as e:
         logger.error(f"Check hccl failed: {e}")
         raise RuntimeError("\"hccl\" wheel was not installed correctly. For details, refer to the installation "
-                           "guidelines: https://www.mindspore.cn/install")
+                           "guidelines: https://www.mindspore.cn/install") from e
 
 
 def init(backend_name=None):
@@ -545,7 +545,7 @@ def get_group_rank_from_world_rank(world_rank_id, group):
     return _get_group_rank_from_world_rank_helper(world_rank_id=world_rank_id, group=group)
 
 
-def create_group(group, rank_ids):
+def create_group(group, rank_ids, options=None):
     """
     Create a user collective communication group.
 
@@ -558,6 +558,18 @@ def create_group(group, rank_ids):
     Args:
         group (str): The name of the communication group to be created.
         rank_ids (list): A list of device IDs.
+        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)
+                }
 
     Raises:
         TypeError: If group is not a string or `rank_ids` is not a list.
@@ -578,22 +590,24 @@ def create_group(group, rank_ids):
             for more details.
 
         >>> import mindspore as ms
-        >>> from mindspore import set_context
-        >>> from mindspore import ops
+        >>> from mindspore import set_context, ops
+        >>> from mindspore._c_expression import GroupOptions
         >>> from mindspore.communication import init, create_group, get_rank
         >>> set_context(mode=ms.GRAPH_MODE)
         >>> ms.set_device(device_target="Ascend")
         >>> init()
         >>> group = "0-7"
         >>> rank_ids = [0,7]
+        >>> options = GroupOptions()
+        >>> options.hccl_config = {"hccl_buffer_size": 400}
         >>> if get_rank() in rank_ids:
-        ...     create_group(group, rank_ids)
+        ...     create_group(group, rank_ids, options)
         ...     allreduce = ops.AllReduce(group)
     """
     if not isinstance(group, str):
         raise TypeError("For 'create_group', the argument 'group' must be type of string, "
                         "but got 'group' type : {}.".format(type(group)))
-    _create_group_helper(group, rank_ids)
+    _create_group_helper(group, rank_ids, options)
 
 
 def destroy_group(group):
@@ -740,3 +754,61 @@ def get_process_group_ranks(group=GlobalComm.WORLD_COMM_GROUP):
 
     """
     return _get_group_ranks(group=_get_group(group))
+
+
+def _comm_switch_nic(global_ranks, use_backup):
+    """Switch network interface card between the primary and the secondary NIC.
+
+    Args:
+        global_ranks (list[int], tuple[int]): list of integers. The global rank ids that need switch network interface .
+        use_backup (list[bool], tuple[int]): list of bool. For each rank id in global_ranks, determine whether to use
+            the backup network interface card. True means use, False means not use.
+
+    Returns:
+        bool, whether the network card switch is successful.
+            If one fails, return False. If all are successful, return True.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For Ascend/GPU/CPU 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.
+
+            This example should be run with 4 devices.
+
+        >>> import numpy as np
+        >>> from mindspore.communication import init, _comm_switch_nic
+        >>> from mindspore.communication.management import _comm_switch_nic
+        >>>
+        >>> init()
+        >>> ret = _comm_switch_nic([0, 1], [True, False])
+        >>> print(ret)
+        True
+
+    """
+    max_rank = get_group_size() - 1
+    if not all(isinstance(i, (list, tuple)) for i in (global_ranks, use_backup)):
+        raise ValueError(f"For _comm_switch_nic, the args 'global_ranks' and 'use_backup' should be list or tuple, "
+                         f"but got 'global_ranks' type {type(global_ranks)}, 'use_backup' type {type(use_backup)}")
+    if not all(isinstance(rank, int) and not isinstance(rank, bool) and rank <= max_rank for rank in global_ranks):
+        raise ValueError(f"For _comm_switch_nic, the all elements  in 'global_ranks' should be int number, and less "
+                         f"than {get_group_size()}, but got 'global_ranks' : {global_ranks}.")
+    if not all(isinstance(ub, bool) for ub in use_backup):
+        raise ValueError(f"For _comm_switch_nic, the all elements  in 'use_backup' should be bool, but got "
+                         f"'use_backup' : {use_backup}.")
+    if len(set(global_ranks)) != len(global_ranks):
+        raise ValueError(f"For _comm_switch_nic, the all elements  in 'global_ranks' should be different, but got "
+                         f"'global_ranks' : {global_ranks}.")
+    if len(global_ranks) != len(use_backup):
+        raise ValueError(f"For _comm_switch_nic, the elements number in 'global_ranks' should be equal to 'use_backup',"
+                         f" but got 'global_ranks' {len(global_ranks)} elements: {global_ranks},"
+                         f" 'use_backup' {len(use_backup)} elements:  {use_backup},.")
+    return _comm_switch_nic_helper(global_ranks, use_backup)

mindspore/context.py

@@ -204,13 +204,6 @@ class _Context:
         if mode == PYNATIVE_MODE:
             if self.enable_debug_runtime:
                 self.set_backend_policy("vm")
-            parallel_mode = _get_auto_parallel_context("parallel_mode")
-            if parallel_mode not in (ParallelMode.DATA_PARALLEL, ParallelMode.STAND_ALONE, ParallelMode.AUTO_PARALLEL):
-                raise ValueError(f"Got {parallel_mode}, when the user enabled SEMI_AUTO_PARALELL, "
-                                 f"pynative mode dose not support, you should set either "
-                                 f"context.set_auto_parallel_context(parallel_mode='data_parallel'), "
-                                 f"context.set_auto_parallel_context(parallel_mode='stand_alone') "
-                                 f"or context.set_auto_parallel_context(parallel_mode='auto_parallel').")
             self._context_switches.push(True, None)
         elif mode == GRAPH_MODE:
             if self.enable_debug_runtime:
@@ -290,6 +283,8 @@ class _Context:
             raise ValueError(f"For 'context.set_context', the argument 'deterministic' must be one of "
                              f"{deterministic_options}, but got {deterministic}.")
 
+        logger.info(f"Set deterministic setting to '{deterministic}'.")
+
         # Must wait for all async created groups to be initialized so that
         # deterministic feature could be consistent between all processes.
         CollectiveManager.get_instance().wait_all_comm_init()
@@ -603,12 +598,12 @@ class _Context:
     def set_mempool_block_size(self, mempool_block_size):
         """Set the block size of memory pool."""
         global_jit_config = get_jit_config()
-        is_force_kbk = False
+        is_ge = False
         if global_jit_config:
-            is_force_kbk = global_jit_config.get('jit_level') == "O0" or global_jit_config.get('jit_level') == "O1"
-        if _get_mode() == GRAPH_MODE and not is_force_kbk:
-            logger.warning("Graph mode doesn't support to set parameter 'mempool_block_size' of context currently, "
-                           "you can use context.set_context to set pynative mode or set jit_level=O0/O1.")
+            is_ge = global_jit_config.get('backend') == "GE" or global_jit_config.get('jit_level') == "O2"
+        if is_ge:
+            logger.warning("GE doesn't support to set parameter 'mempool_block_size' of context currently, "
+                           "you can use pynative mode or set jit_level=O0/O1.")
             return
         if not Validator.check_str_by_regular(mempool_block_size, _RE_PATTERN):
             raise ValueError("For 'context.set_context', the argument 'mempool_block_size' should be in "
@@ -838,6 +833,26 @@ class _Context:
             raise TypeError(f"For step num, the value type should be int, but got {type(step)}, {step}")
         self.set_param(ms_ctx_param.last_triggered_step, step)
 
+    @staticmethod
+    def _check_speedup_config_str_value(key, value):
+        """check speedup config str value"""
+        if key in ["pp_1f1b_overlap", "recompute_comm_overlap", "recomputation_communication_overlap",
+                   "matmul_grad_comm_overlap", "grad_matmul_communication_overlap"]:
+            if isinstance(value, str):
+                values = value.split(",")
+                for v in values:
+                    if v not in ['AlltoAll', 'AlltoAllV', 'MorphAllGather', 'AllReduce',
+                                 'AllGather', 'ReduceScatter', 'MorphReduceScatter', '']:
+                        raise ValueError("{} 's value should be subset of ['AlltoAll', 'AlltoAllV',"
+                                         " 'MorphAllGather', 'AllGather', 'ReduceScatter',"
+                                         " 'MorphReduceScatter', 'AllReduce'].".format(key))
+                return value
+            if value:
+                return "AlltoAll,AlltoAllV,AllGather,ReduceScatter,AllReduce"
+            return ""
+
+        return value
+
     def _set_speedup_config_path(self, speedup_config_path):
         """"Check and set speedup config for auto parallel."""
         if speedup_config_path is None or speedup_config_path == "":
@@ -848,10 +863,10 @@ class _Context:
                              f"{speedup_config_real_path} does not exist, please check whether the "
                              f"'parallel_speed_up_json_path' is correct.")
         try:
-            valid_option = {"recompute_comm_overlap": (ms_ctx_param.recompute_comm_overlap, bool),
-                            "recomputation_communication_overlap": (ms_ctx_param.recompute_comm_overlap, bool),
-                            "matmul_grad_comm_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
-                            "grad_matmul_communication_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
+            valid_option = {"recompute_comm_overlap": (ms_ctx_param.recompute_comm_overlap, str),
+                            "recomputation_communication_overlap": (ms_ctx_param.recompute_comm_overlap, str),
+                            "matmul_grad_comm_overlap": (ms_ctx_param.matmul_grad_comm_overlap, (bool, str)),
+                            "grad_matmul_communication_overlap": (ms_ctx_param.matmul_grad_comm_overlap, (bool, str)),
                             "enable_task_opt": (ms_ctx_param.enable_task_opt, bool),
                             "enable_communication_fusion": (ms_ctx_param.enable_task_opt, bool),
                             "enable_grad_comm_opt": (ms_ctx_param.enable_grad_comm_opt, bool),
@@ -908,17 +923,12 @@ class _Context:
                                        f"Please use '{name_replace.get(key)}' instead.")
                     set_func, valid_type = valid_option.get(key)
                     if not isinstance(value, valid_type):
-                        raise TypeError(f"The value type of {key} must be {valid_type}, "
-                                        f"but got value is {value} and type is {type(value)}.")
-                    if key == "pp_1f1b_overlap":
-                        values = value.split(",")
-                        for v in values:
-                            if v not in ['AlltoAll', 'AlltoAllV', 'MorphAllGather',
-                                         'AllGather', 'ReduceScatter', 'MorphReduceScatter']:
-                                raise ValueError("{} 's value should be subset of ['AlltoAll', 'AlltoAllV',"
-                                                 " 'MorphAllGather', 'AllGather', 'ReduceScatter',"
-                                                 " 'MorphReduceScatter'].".format(key))
-                    self.set_param(set_func, value)
+                        if not ((key == "recompute_comm_overlap" or key == "recomputation_communication_overlap")
+                                and isinstance(value, bool)):
+                            raise TypeError(f"The value type of {key} must be {valid_type}, "
+                                            f"but got value is {value} and type is {type(value)}.")
+                    value_new = self._check_speedup_config_str_value(key, value)
+                    self.set_param(set_func, value_new)
         except (TypeError, ValueError) as exo:
             raise ValueError(str(exo) + "\nFor 'context.set_context', "
                                         "open or load the 'speedup_config_path' file {} "
@@ -1071,8 +1081,8 @@ def set_auto_parallel_context(**kwargs):
 
                         - pipeline_interleave(bool): Indicates whether to enable the interleaved execution mode.
                         - pipeline_scheduler(str): Indicates the scheduling mode for pipeline parallelism. Only support
-                          ``gpipe/1f1b/seqpipe/seqvpp/seqsmartvpp``. When applying seqsmartvpp, the pipeline parallel
-                          must be an even number.
+                          ``gpipe/1f1b/seqpipe/seqvpp/seqsmartvpp/zero_bubble_v``. When applying seqsmartvpp,
+                          the pipeline parallel must be an even number.
         parallel_optimizer_config (dict): A dict contains the keys and values for setting the parallel optimizer
                         configure. The configure provides more detailed behavior control about parallel training
                         when parallel optimizer is enabled. The configure will be effective when we use
@@ -1557,7 +1567,8 @@ def set_context(**kwargs):
         check_bprop (bool): This parameter will be deprecated and removed in future versions.
         enable_reduce_precision (bool): This parameter will be deprecated and removed in a future versions.
         grad_for_scalar (bool): This parameter will be deprecated and removed in future versions.
-        support_binary (bool): Whether to support run .pyc or .so in graph mode.
+        support_binary (bool): Whether to support run .pyc or .so in graph mode. This parameter will be deprecated and
+            removed in a future version. Please use the environment variable `MS_SUPPORT_BINARY` instead.
 
     Examples:
         >>> import mindspore as ms
@@ -1769,8 +1780,9 @@ def set_ps_context(**kwargs):
                           Default: ``False`` .
         config_file_path (str): Configuration file path used by recovery, parameter server training mode only
                                    supports Server disaster recovery currently. Default: ``''`` .
-        scheduler_manage_port (int): Scheduler manage port used to scale out/in. Default: ``11202`` .
-        enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False`` .
+        enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False``.
+                           When set to False, users need to review and confirm the security of network environment
+                           where the distributed job is located.
         client_password (str): Password to decrypt the secret key stored in the client certificate. Default: ``''`` .
         server_password (str): Password to decrypt the secret key stored in the server certificate. Default: ``''`` .
 
@@ -1779,7 +1791,7 @@ def set_ps_context(**kwargs):
 
     Examples:
         >>> import mindspore as ms
-        >>> ms.set_ps_context(enable_ps=True, enable_ssl=True, client_password='123456', server_password='123456')
+        >>> ms.set_ps_context(enable_ps=True, enable_ssl=True, client_password='', server_password='')
     """
     _set_ps_context(**kwargs)
 
@@ -1796,12 +1808,9 @@ def get_ps_context(attr_key):
             - config_file_path (str, optional): Configuration file path used by recovery,
               parameter server training mode only
               supports Server disaster recovery currently. Default: ``''`` .
-            - scheduler_manage_port (int, optional): Scheduler manage port used to scale out/in. Default: ``11202`` .
             - enable_ssl (bool, optional): Set PS SSL mode enabled or disabled. Default: ``False`` .
-            - client_password (str, optional): Password to decrypt the secret key stored in the client certificate.
-              Default: ``''`` .
-            - server_password (str, optional): Password to decrypt the secret key stored in the server certificate.
-              Default: ``''`` .
+              When set to False, users need to review and confirm the security of network environment
+              where the distributed job is located.
 
     Returns:
         Returns attribute value according to the key.

mindspore/dataset/__init__.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """
 At the heart of MindSpore data loading utility is the `mindspore.dataset` module.
-It is a `dataset engine <https://www.mindspore.cn/docs/en/master/design/data_engine.html>`_ based on pipline design.
+It is a `dataset engine <https://www.mindspore.cn/docs/en/master/features/data_engine.html>`_ based on pipline design.
 
 This module provides the following data loading methods to help users load datasets into MindSpore.
 

mindspore/dataset/audio/transforms.py

@@ -2793,7 +2793,7 @@ class PhaseVocoder(AudioTensorOperation):
     Raises:
         TypeError: If `rate` is not of type float.
         ValueError: If `rate` is not a positive number.
-        TypeError: If `phase_advance` is not of type :class:`numpy.ndarray` .
+        TypeError: If `phase_advance` is not of type `numpy.ndarray` .
         RuntimeError: If input tensor is not in shape of <..., freq, num_frame, complex=2>.
 
     Supported Platforms:

mindspore/dataset/core/config.py

@@ -34,7 +34,6 @@ from mindspore.dataset.core.validator_helpers import replace_none, type_check, c
 from mindspore.dataset.debug import DebugHook, PrintMetaDataHook
 from mindspore.dataset.core.validator_helpers import check_independent_mode
 
-
 __all__ = ['set_sending_batches', 'load', '_init_device_info',
            'set_seed', 'get_seed',
            'set_prefetch_size', 'get_prefetch_size',
@@ -1097,12 +1096,12 @@ def get_error_samples_mode():
     return _CDE_TO_PYTHON_ERROR_SAMPLES_MODE.get(_config.get_error_samples_mode())
 
 
-def set_iterator_mode(do_copy=True, parallel_convert=False):
+def set_iterator_mode(do_copy=False, parallel_convert=False):
     """
     Select dataset iterator optimization strategy.
 
     Args:
-        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "True".
+        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "False".
         parallel_convert (bool): Whether dataset iterator starts a thread to organize Tensors to output.
             Default: "False".
 
@@ -1122,7 +1121,7 @@ def set_iterator_mode(do_copy=True, parallel_convert=False):
 def get_iterator_mode():
     """
     Get dataset iterator mode indicate iterator optimization strategy.
-    If `set_iterator_mode` is never called before, `do_copy` default to "True", `parallel_convert` default to "False".
+    If `set_iterator_mode` is never called before, `do_copy` default to "False", `parallel_convert` default to "False".
 
     Returns:
         dict, iterator mode dictionary contains the value of `do_copy` and `parallel_convert`.
@@ -1174,3 +1173,38 @@ def get_multiprocessing_start_method():
         >>> multiprocessing_start_method = ds.config.get_multiprocessing_start_method()
     """
     return _config.get_multiprocessing_start_method()
+
+
+def set_video_backend(backend):
+    """
+    Set the backend used to decode videos.
+
+    Args:
+        backend (str): Type of the video backend. It can be "CPU" or "Ascend".
+
+    Raises:
+        TypeError: If `backend` is not of type str.
+        ValueError: If `backend` is not "CPU" or "Ascend".
+
+    Examples:
+        >>> import mindspore.dataset as ds
+        >>> ds.config.set_video_backend("CPU")
+    """
+
+    type_check(backend, (str,), "backend")
+    check_valid_str(backend, ["CPU", "Ascend"], "backend")
+    _config.set_video_backend(backend)
+
+
+def get_video_backend():
+    """
+    Returns the currently active backend used to decode videos.
+
+    Returns:
+        str, backend used to decode videos.
+
+    Examples:
+        >>> import mindspore.dataset as ds
+        >>> backend = ds.config.get_video_backend()
+    """
+    return _config.get_video_backend()