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

mindspore/common/tensor.py

@@ -419,6 +419,9 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
     def __rmod__(self, other):
         return _rmod_instance(other, self)
 
+    def __imod__(self, other):
+        return self.__mod__(other)
+
     def __rpow__(self, other):
         return tensor_operator_registry.get('__rpow__')(self, other)
 
@@ -1147,6 +1150,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
               which may be modified by returning a new output gradient.
             - The `hook` should have the following signature:
               hook(grad) -> New output gradient, but can not return None or not set return value.
+            - Higher-order differentiation does not support tensor `register_hook`.
             - The following constraints must be met under graph mode:
 
               - The `hook` must satisfy the syntax constraints of the graph mode.
@@ -1851,10 +1855,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
 
             self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2
 
-        .. warning::
-            When deterministic computation is enabled, `index` can not be a non-contiguous Tensor; otherwise,
-            deterministic results can not be guaranteed.
-
         Args:
             dim (int): Which dim to scatter. Accepted range is [-r, r) where r = rank(`self`).
             index (Tensor): The index of `self` to do scatter operation whose data type must
@@ -2101,9 +2101,9 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         try:
             dtype_ = mstype.int8 if is_qint4x2 else self.dtype
             if isinstance(self.init, ZeroInitializer):
-                data = np.zeros(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
+                data = np.zeros(data_shape, dtype=mstype.dtype_to_nptype(dtype_))
             else:
-                data = np.ndarray(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
+                data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(dtype_))
         except ValueError as e:
             msg = "Error shape={}".format(shape)
             logger.critical(msg)
@@ -2586,34 +2586,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('bernoulli')(self, generator=generator)
 
-    def bernoulli_(self, p=0.5, *, generator=None):
-        r"""
-        Fills each location of self with an independent sample from Bernoulli(p).
-
-        Args:
-            p (Union[number.Number, Tensor], optional): `p` should either be a scalar or tensor containing
-                probabilities to be used for drawing the binary random number, between ``0`` and ``1`` .
-                If it is a tensor, `p` must be floating point. Default: ``0.5`` .
-
-        Keyword Args:
-            generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
-                Default: ``None`` , uses the default pseudorandom number generator.
-
-        Returns:
-            The input tensor.
-
-        Supported Platforms:
-            ``Ascend``
-
-        Examples:
-            >>> from mindspore import Tensor
-            >>> x = Tensor([[2, 3, 4], [1, 2, 3]])
-            >>> p = 0.1
-            >>> print(x.bernoulli_(p).shape)
-            (2, 3)
-        """
-        return tensor_operator_registry.get('bernoulli_')(self, p, generator=generator)
-
     def random_(self, from_=0, to=None, *, generator=None):
         r"""
         Fill the tensor with numbers sampled from a discrete uniform distribution over an
@@ -2967,8 +2939,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
               taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
 
         Args:
-            dtype (dtype.Number, bool): The valid data type of the output tensor. Only constant value is allowed.
-                Only Support type bool in PyNative mode.
+            dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
 
         Returns:
             Tensor, converted to the specified `dtype`.
@@ -3628,6 +3599,46 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('ormqr')(self, input2, input3, left, transpose)
 
+    def masked_scatter(self, mask, x):
+        r"""
+        Updates the value in the "self Tensor" with the `tensor` value according to the mask, and returns a Tensor.
+        The shape of `mask` and the "self Tensor" must be the same or `mask` is broadcastable.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            mask (Tensor[bool]): A bool tensor with a shape broadcastable to the "self Tensor".
+            x (Tensor): A tensor with the same data type as the "self Tensor". The number
+                of elements must be greater than or equal to the number of True's in `mask`.
+
+        Returns:
+            Tensor, with the same type and shape as the "self Tensor".
+
+        Raises:
+            TypeError: If `mask` or `x` is not a Tensor.
+            TypeError: If data type of the "self Tensor" is not be supported.
+            TypeError: If dtype of `mask` is not bool.
+            TypeError: If the dim of the "self Tensor" less than the dim of `mask`.
+            ValueError: If `mask` can not be broadcastable to the "self Tensor".
+            ValueError: If the number of elements in `x` is less than the number required for the updates.
+
+        Supported Platforms:
+            ``Ascend`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+            >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
+            >>> tensor = Tensor(np.array([5., 6., 7.]), mindspore.float32)
+            >>> output = x.masked_scatter(mask, tensor)
+            >>> print(output)
+            [5. 6. 3. 7.]
+        """
+        return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
+
     def index_put(self, indices, values, accumulate=False):
         r"""
         Based on the indices in `indices`, replace the corresponding elements in Tensor `self`
@@ -3768,6 +3779,9 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             raise ValueError(f"The type of 'blocking' must be bool, but got {blocking}")
         if to not in ("Ascend", "GPU", "CPU"):
             raise ValueError(f"The value of 'to' must be one of ['Ascend', 'GPU', 'CPU'], but got {to}")
+        mode = context.get_context("mode")
+        if mode != context.PYNATIVE_MODE:
+            raise ValueError(f"The method of 'move_to' only supported in pynative mode, but got: {mode}.")
         return TensorPy_.move_to(self, to, blocking)
 
     def _offload(self):
@@ -3937,9 +3951,9 @@ def _check_astype_and_convert(dtype):
         if dtype.lower() not in all_types:
             raise TypeError(f"For Tensor.astype, the string input type must be one of {all_types}, "
                             f"but got '{dtype}'.")
-        dtype = mstype._pytype_to_dtype(np.dtype(dtype.lower()))  # pylint:disable=protected-access
+        dtype = mstype.pytype_to_dtype(np.dtype(dtype.lower()))
     elif isinstance(dtype, type):
-        dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
+        dtype = mstype.pytype_to_dtype(dtype)
     elif dtype not in mstype.number_type + (mstype.bool_,):
         raise TypeError(
             f"For Tensor.astype, the input type must be one of {list(mstype.number_type + (mstype.bool_,) + np_types)},"

mindspore/communication/_hccl_management.py

@@ -0,0 +1,297 @@
+# Copyright 2020 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.
+# ============================================================================
+"""HCCL management API"""
+from __future__ import absolute_import
+from __future__ import division
+
+import ctypes
+import os
+
+from mindspore import context
+from mindspore._c_expression import get_hccl_rank_id, get_hccl_rank_size
+
+MAX_GROUP_NAME_LEN = 127
+MAX_RANK_NUM = 4096
+HCCL_LIB = 'libhccl_plugin.so'
+HCCL_LIB_CTYPES = ""
+
+
+def check_group(group):
+    """
+    A function that check if a collection communication group is legal.
+
+    Returns:
+        None
+    """
+    if isinstance(group, (str)):
+        group_len = len(group)
+        if group_len > MAX_GROUP_NAME_LEN or group_len == 0:
+            raise ValueError("The length of communication group name must be in range [1, 127), "
+                             "but got the value : {} ".format(group_len))
+    else:
+        raise TypeError("The type of communication group name must be type of string, "
+                        "but got 'group' type : {}.".format(type(group)))
+
+
+def check_rank_num(rank_num):
+    """
+    A function that check if a collection communication rank number is legal.If not raise error.
+
+    Returns:
+        None
+    """
+    if isinstance(rank_num, (int)):
+        if rank_num > MAX_RANK_NUM or rank_num <= 0:
+            raise ValueError("For 'create_group', the size of argument 'rand_ids' should be greater than 0 and"
+                             "less than {}, but got the size of 'rank_ids' : {}.".format(MAX_RANK_NUM, rank_num))
+    else:
+        raise TypeError("The argument 'rank_num' must be type of int, "
+                        "but got 'rank_num' type : {}.".format(type(rank_num)))
+
+
+def check_rank_id(rank_id):
+    """
+    A function that check if a collection communication rank id is legal.If not raise error.
+
+    Returns:
+        None
+    """
+    if isinstance(rank_id, (int)):
+        if rank_id >= MAX_RANK_NUM or rank_id < 0:
+            raise ValueError("The rand id in the communication group must be greater or equal 0 and "
+                             "less than {}, but got type value : {}.".format(MAX_RANK_NUM, rank_id))
+    else:
+        raise TypeError("The rand id in the communication group must be must be type of int, "
+                        "but got type value : {}.".format(type(rank_id)))
+
+
+def load_lib():
+    """load hccl lib"""
+    try:
+        base_dir = os.path.dirname(os.path.realpath(__file__))
+        lib_path = os.path.join(base_dir, "../lib/plugin/ascend", HCCL_LIB)
+        hccl_lib = ctypes.CDLL(lib_path)
+    except Exception:
+        raise RuntimeError('Get hccl lib error.')
+
+    global HCCL_LIB_CTYPES
+    HCCL_LIB_CTYPES = hccl_lib
+
+
+def c_str(string):
+    """Convert a python string to C string."""
+    if not isinstance(string, str):
+        string = string.decode('ascii')
+    return ctypes.c_char_p(string.encode('utf-8'))
+
+
+def c_array(ctype, values):
+    """Create ctypes array from a python array."""
+    return (ctype * len(values))(*values)
+
+
+def create_group(group, rank_num, rank_ids):
+    """
+    Create group.
+
+    A function that creates a collection communication group which includes 'rank_num'
+    device and 'rank_ids' is the list of these ranks of devices.
+
+    Note:
+        The world group can not be created.
+
+    Returns:
+        None
+    """
+    check_group(group)
+    check_rank_num(rank_num)
+    if isinstance(rank_ids, (list)):
+        if rank_num != len(rank_ids):
+            raise ValueError("The argument 'rank_num' number should be equal to the length "
+                             "of rank_ids, but got 'rank_num' value : {} and 'rank_ids' value : {}."
+                             .format(rank_num, rank_ids))
+        for rank_id in rank_ids:
+            if not isinstance(rank_id, (int)) or rank_id < 0:
+                raise ValueError("The elements of argument 'rank_ids' must be "
+                                 "unsigned integer, but got the type : {}".format(type(rank_id)))
+        c_array_rank_ids = c_array(ctypes.c_uint, rank_ids)
+        c_rank_num = ctypes.c_uint(rank_num)
+        c_group = c_str(group)
+        ret = HCCL_LIB_CTYPES.HcomCreateGroup(c_group, c_rank_num, c_array_rank_ids)
+        if ret != 0:
+            raise RuntimeError('Create group error, the error code is {}.'.format(ret))
+    else:
+        raise TypeError("For 'create_group', the argument 'rank_ids' must be type of list, "
+                        "but got 'rank_ids' type : {}.".format(type(rank_ids)))
+
+
+def destroy_group(group):
+    """
+    A function that destroy the group which created by user.
+
+    Note:
+        The world group can not be destroy.
+
+    Returns:
+        None
+    """
+    check_group(group)
+    c_group = c_str(group)
+    ret = HCCL_LIB_CTYPES.HcomDestroyGroup(c_group)
+    if ret != 0:
+        raise RuntimeError('Destroy group error.')
+
+
+def get_rank_size(group="hccl_world_group"):
+    """
+    A function that returns the number of ranks within the given collection communication group.
+
+    Note:
+        The default group is hccl_world_group.
+
+    Returns:
+        An integer scalar with the num of ranks.
+    """
+
+    if context.get_context("mode") == context.PYNATIVE_MODE:
+        return get_hccl_rank_size()
+
+    check_group(group)
+    c_group = c_str(group)
+    c_rank_size = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetRankSize(c_group, ctypes.byref(c_rank_size))
+    if ret != 0:
+        raise RuntimeError('Get rank size error.')
+
+    return c_rank_size.value
+
+
+def get_rank_id(group="hccl_world_group"):
+    """
+    A function that returns the rank id of the calling process, within the given collection communication group.
+
+    Returns:
+        An integer scalar with the rank id of the calling process.
+    """
+
+    if context.get_context("mode") == context.PYNATIVE_MODE:
+        return get_hccl_rank_id()
+
+    check_group(group)
+    c_group = c_str(group)
+    c_rank_id = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetRankId(c_group, ctypes.byref(c_rank_id))
+    if ret != 0:
+        raise RuntimeError('Get rank id error.')
+
+    return c_rank_id.value
+
+
+
+def get_local_rank_size(group="hccl_world_group"):
+    """
+    A function that returns the number of local ranks within the given collection communication group.
+
+    Note:
+        The default group is hccl_world_group.
+
+    Returns:
+        An integer scalar with the num of local ranks.
+    """
+    if context.get_context("mode") is context.PYNATIVE_MODE:
+        raise RuntimeError("The function 'get_local_rank_size' is not supported in PYNATIVE_MODE, "
+                           "'get_local_rank_size' only support GRAPH_MODE")
+    check_group(group)
+    c_group = c_str(group)
+    c_local_rank_size = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetLocalRankSize(c_group, ctypes.byref(c_local_rank_size))
+    if ret != 0:
+        raise RuntimeError('Get local rank size error.')
+
+    return c_local_rank_size.value
+
+
+def get_local_rank_id(group="hccl_world_group"):
+    """
+    Get local rank id.
+
+    A function that returns the local rank id of the calling process, within the given collection communication group.
+
+    Returns:
+        An integer scalar with the local rank id of the calling process.
+    """
+
+    if context.get_context("mode") is context.PYNATIVE_MODE:
+        raise RuntimeError("The function 'get_local_rank_id' is not supported in PYNATIVE_MODE, "
+                           "'get_local_rank_id' only support GRAPH_MODE")
+    check_group(group)
+    c_group = c_str(group)
+    c_local_rank_id = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetLocalRankId(c_group, ctypes.byref(c_local_rank_id))
+    if ret != 0:
+        raise RuntimeError('Get local rank id error.')
+
+    return c_local_rank_id.value
+
+
+def get_world_rank_from_group_rank(group, group_rank_id):
+    """
+    Get world rank from group rank.
+
+    A function that returns the rank id in the world group corresponding to the
+    rank which id is 'group_rank_id' in the user group.
+
+    Returns:
+        An integer scalar with the rank id in the world group.
+    """
+    if context.get_context("mode") is context.PYNATIVE_MODE:
+        raise RuntimeError("The function 'get_world_rank_from_group_rank' is not supported in PYNATIVE_MODE, "
+                           "'get_world_rank_from_group_rank' only support GRAPH_MODE")
+    check_group(group)
+    check_rank_id(group_rank_id)
+    c_group = c_str(group)
+    c_group_rank_id = ctypes.c_uint(group_rank_id)
+    c_world_rank_id = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetWorldRankFromGroupRank(c_group, c_group_rank_id, ctypes.byref(c_world_rank_id))
+    if ret != 0:
+        raise RuntimeError('Get world rank from group rank error.')
+
+    return c_world_rank_id.value
+
+
+def get_group_rank_from_world_rank(world_rank_id, group):
+    """
+    Get group rank from world rank.
+
+    A function that returns the rank id in the user group corresponding to the
+    rank which id is 'world_rank_id' in the world group.
+
+    Returns:
+        An integer scalar with the rank id in the user group.
+    """
+    if context.get_context("mode") is context.PYNATIVE_MODE:
+        raise RuntimeError("The function 'get_group_rank_from_world_rank' is not supported in PYNATIVE_MODE, "
+                           "'get_group_rank_from_world_rank' only support GRAPH_MODE")
+    check_group(group)
+    check_rank_id(world_rank_id)
+    c_group = c_str(group)
+    c_world_rank_id = ctypes.c_uint(world_rank_id)
+    c_group_rank_id = ctypes.c_uint()
+    ret = HCCL_LIB_CTYPES.HcomGetGroupRankFromWorldRank(c_world_rank_id, c_group, ctypes.byref(c_group_rank_id))
+    if ret != 0:
+        raise RuntimeError('Get group rank from world rank error.')
+
+    return c_group_rank_id.value

mindspore/context.py

@@ -204,6 +204,13 @@ 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:
@@ -598,12 +605,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_ge = False
+        is_force_kbk = False
         if global_jit_config:
-            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.")
+            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.")
             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 "
@@ -836,8 +843,7 @@ 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",
-                   "matmul_grad_comm_overlap", "grad_matmul_communication_overlap"]:
+        if key in ["pp_1f1b_overlap", "recompute_comm_overlap", "recomputation_communication_overlap"]:
             if isinstance(value, str):
                 values = value.split(",")
                 for v in values:
@@ -865,8 +871,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, str)),
-                            "grad_matmul_communication_overlap": (ms_ctx_param.matmul_grad_comm_overlap, (bool, 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),
                             "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),
@@ -1081,8 +1087,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/zero_bubble_v``. When applying seqsmartvpp,
-                          the pipeline parallel must be an even number.
+                          ``gpipe/1f1b/seqpipe/seqvpp/seqsmartvpp``. 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
@@ -1781,8 +1787,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``.
-                           When set to False, users need to review and confirm the security of network environment
-                           where the distributed job is located.
+                           Turning it off by default may be a security risk,
+                           and users need to ensure the security of the network environment.
         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: ``''`` .
 
@@ -1809,8 +1815,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`` .
-              When set to False, users need to review and confirm the security of network environment
-              where the distributed job is located.
+              Turning it off by default may be a security risk,
+              and users need to ensure the security of the network environment.
 
     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/features/data_engine.html>`_ based on pipline design.
+It is a `dataset engine <https://www.mindspore.cn/docs/en/master/design/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 `numpy.ndarray` .
+        TypeError: If `phase_advance` is not of type :class:`numpy.ndarray` .
         RuntimeError: If input tensor is not in shape of <..., freq, num_frame, complex=2>.
 
     Supported Platforms:

mindspore/dataset/core/config.py

@@ -34,6 +34,7 @@ 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',
@@ -1173,38 +1174,3 @@ 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()