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

mindspore/context.py

@@ -33,13 +33,12 @@ from mindspore.parallel._auto_parallel_context import _set_auto_parallel_context
     _reset_auto_parallel_context
 from mindspore.parallel._ps_context import _set_ps_context, _get_ps_context, _reset_ps_context, \
     _need_reset_device_target_for_ps
-from mindspore.parallel._offload_context import _set_offload_context, _get_offload_context
 from mindspore.hal.device import is_initialized
 from mindspore.common import api
 
 __all__ = ['GRAPH_MODE', 'PYNATIVE_MODE', 'STRICT', 'COMPATIBLE', 'LAX', 'set_context', 'get_context',
            'set_auto_parallel_context', 'get_auto_parallel_context', 'reset_auto_parallel_context', 'ParallelMode',
-           'set_ps_context', 'get_ps_context', 'reset_ps_context', 'set_offload_context', 'get_offload_context']
+           'set_ps_context', 'get_ps_context']
 
 GRAPH_MODE = 0
 PYNATIVE_MODE = 1
@@ -204,13 +203,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 does 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:
@@ -262,22 +254,6 @@ class _Context:
                              f"{exec_order_modes}, but got {exec_order}.")
         self.set_param(ms_ctx_param.exec_order, exec_order)
 
-    def set_memory_offload(self, memory_offload):
-        """
-        Enable memory offload or not, support "ON", "OFF".
-
-        Args:
-            memory_offload (str): "ON", "OFF"
-        """
-        memory_offload_options = ["ON", "OFF"]
-        if memory_offload not in memory_offload_options:
-            raise ValueError(f"For 'context.set_context', the argument 'memory_offload' must be one of "
-                             f"{memory_offload_options}, but got {memory_offload}.")
-        if memory_offload == "ON":
-            self.set_param(ms_ctx_param.memory_offload, True)
-        else:
-            self.set_param(ms_ctx_param.memory_offload, False)
-
     def set_deterministic(self, deterministic):
         """
         Enable model run in deterministic, and support the values "ON" and "OFF".
@@ -605,12 +581,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 "
@@ -693,7 +669,6 @@ class _Context:
         'memory_optimize_level': set_memory_optimize_level,
         'exec_order': set_exec_order,
         'op_timeout': set_op_timeout,
-        'memory_offload': set_memory_offload,
         'deterministic': set_deterministic,
         'ascend_config': set_ascend_config,
         'jit_syntax_level': set_jit_syntax_level,
@@ -843,7 +818,8 @@ class _Context:
     @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"]:
+        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:
@@ -871,8 +847,8 @@ class _Context:
         try:
             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),
-                            "grad_matmul_communication_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
+                            "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),
@@ -1087,8 +1063,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
@@ -1272,65 +1248,6 @@ def reset_auto_parallel_context():
     api.ms_compile_cache.clear()
 
 
-@args_type_check(offload_config=dict)
-def set_offload_context(offload_config):
-    r"""
-    Configure heterogeneous training detailed parameters to adjust the offload strategy, this api will be deprecated
-    and removed in future versions.
-
-    Note:
-        The offload configuration is only used if the memory offload feature is enabled
-        via mindspore.set_context(memory_offload="ON"), and the memory_optimize_level must be set to O0. On the Ascend
-        hardware platform, the graph compilation level must be O0.
-
-    Args:
-        offload_config (dict): A dict contains the keys and values for setting the offload context
-            configure.It supports the following keys.
-
-            - offload_path (str):  The path of offload, relative paths are supported. Default: ``"./offload"``.
-            - offload_cpu_size (str):  The cpu memory size for offload. The format is "xxGB".
-            - offload_disk_size (str): The disk size for offload. The format is "xxGB"
-            - hbm_ratio (float): The ratio that can be used based on the maximum device memory.
-              The range is (0,1], Default: ``1.0``.
-            - cpu_ratio (float): The ratio that can be used based on the maximum host memory.
-              The range is (0,1], Default: ``1.0``.
-            - enable_pinned_mem (bool): The flag of whether enabling Pinned Memory. Default: ``True``.
-            - enable_aio (bool): The flag of whether enabling aio. Default: ``True``.
-            - aio_block_size (str): The size of aio block. The format is "xxGB".
-            - aio_queue_depth (int): The depth of aio queue.
-            - offload_param (str):  The param for offload destination, cpu or disk, Default: ``""``.
-            - offload_checkpoint (str):  The checkpoint for offload destination, only valid if recompute is turned on,
-              cpu or disk, Default: ``""``.
-            - auto_offload (bool): The flag of whether auto offload. Default: ``True``.
-            - host_mem_block_size (str): The memory block size of host memory pool. The format is "xxGB"
-
-    Raises:
-        ValueError: If input key is not attribute in auto parallel context.
-
-    Examples:
-        >>> from mindspore import context
-        >>> context.set_offload_context(offload_config={"offload_param":"cpu"})
-    """
-    _set_offload_context(offload_config)
-
-
-def get_offload_context():
-    """
-    Gets the offload configuration parameters, this api will be deprecated and removed in future versions.
-
-    Configure through interface mindspore.set_offload_context(). If the user is not set, the default configuration is
-    obtained.
-
-    Returns:
-        Dict, heterogeneous training offload detailed configuration parameters.
-
-    Examples:
-        >>> from mindspore import context
-        >>> offload_config = context.get_offload_context()
-    """
-    return _get_offload_context()
-
-
 def _check_target_specific_cfgs(device, arg_key):
     """Checking whether a config is suitable for a specified device"""
     device_cfgs = {
@@ -1406,8 +1323,7 @@ def _check_context_deprecated(key):
                                                      mindspore.device_context.gpu.op_precision.conv_fprop_algo(),
                                                      mindspore.device_context.gpu.op_precision.conv_wgrad_algo(),
                                                      mindspore.device_context.gpu.op_precision.conv_dgrad_algo()''',
-                               'runtime_num_threads': 'api mindspore.device_context.cpu.op_tuning.threads_num()',
-                               'memory_offload': "`device` parameter of `mindspore.Parameter`"}
+                               'runtime_num_threads': 'api mindspore.device_context.cpu.op_tuning.threads_num()'}
     invalid_context_dict = {
         'exception_dump': {'version': '2.6', 'interface': 'device_context.ascend.op_debug.aclinit_config()'}
     }
@@ -1474,9 +1390,6 @@ def set_context(**kwargs):
         inter_op_parallel_num(int): The thread number of op parallel at the same time.
             Default ``0`` . This parameter will be deprecated and removed in future versions.
             Please use the api :func:`mindspore.runtime.dispatch_threads_num` instead.
-        memory_offload (str): Whether to enable the memory offload function. Default ``"OFF"`` .
-            This parameter will be deprecated and removed in future versions. Please use the api
-            :func:`mindspore.nn.Cell.offload` instead.
         disable_format_transform (bool): Whether to disable the automatic format transform function from NCHW
             to NHWC. Default ``False`` . This parameter will be deprecated and removed in future versions. Please
             use the related parameter of :func:`mindspore.jit` instead.
@@ -1546,7 +1459,9 @@ def set_context(**kwargs):
               This parameter will be deprecated and removed in future versions. Please use the
               api :func:`mindspore.parallel.auto_parallel.AutoParallel.transformer_opt` instead.
             - hccl_watchdog (bool): Enable a thread to monitor the failure of collective communication.
-              Default ``True`` .
+              Default ``True`` . This parameter will be deprecated and removed in future versions. Please use the
+              environment variable `MS_ENABLE_THM="{HCCL_WATCHDOG:1}"` instead.
+
         gpu_config (dict): Set the parameters specific to gpu hardware platform. It is not set by default.
 
             - conv_fprop_algo (str): Specifies convolution forward algorithm. Default ``"normal"`` .
@@ -1601,7 +1516,6 @@ def set_context(**kwargs):
         >>> ms.set_context(inter_op_parallel_num=4)
         >>> ms.set_context(disable_format_transform=True)
         >>> ms.set_context(memory_optimize_level='O0')
-        >>> ms.set_context(memory_offload='ON')
         >>> ms.set_context(deterministic='ON')
         >>> ms.set_context(ascend_config={"precision_mode": "force_fp16", "jit_compile": True,
         ...                "atomic_clean_policy": 1, "op_precision_mode": "./op_precision_config_file",
@@ -1787,8 +1701,8 @@ def set_ps_context(**kwargs):
         config_file_path (str): Configuration file path used by recovery, parameter server training mode only
                                    supports Server disaster recovery currently. Default: ``''`` .
         enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False``.
-                           Turning it off by default may be a security risk,
-                           and users need to ensure the security of the network environment.
+                           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: ``''`` .
 
@@ -1815,8 +1729,8 @@ def get_ps_context(attr_key):
               parameter server training mode only
               supports Server disaster recovery currently. Default: ``''`` .
             - enable_ssl (bool, optional): Set PS SSL mode enabled or disabled. Default: ``False`` .
-              Turning it off by default may be a security risk,
-              and users need to ensure the security of the network environment.
+              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',
@@ -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()