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

mindspore/common/recompute.py

@@ -18,15 +18,15 @@ from collections import OrderedDict
 from types import MethodType
 from mindspore import log as logger
 from mindspore.nn.cell import Cell
-from mindspore import context
 from mindspore.common.tensor import Tensor
 from mindspore import ops
 from mindspore.ops.composite import GradOperation
 from mindspore.common._register_for_recompute import recompute_registry
 from mindspore.common.api import _pynative_executor, _no_grad
 from mindspore.common.generator import get_rng_state, set_rng_state
-from mindspore.train.amp import amp_decorator
+from mindspore.train.amp import AmpDecorator
 from mindspore._c_expression.amp import get_curr_amp_strategy
+from mindspore._check_jit_forbidden_api import jit_forbidden_register
 
 
 class _WrapCell(Cell):
@@ -104,8 +104,8 @@ class _RecomputeCell(Cell):
             set_rng_state(self.cpu_rng_state)
             _pynative_executor.set_is_run_recompute(True)
             if self.amp_strategy:
-                with amp_decorator(self.amp_strategy.get_amp_level(), self.amp_strategy.get_amp_dtype(),
-                                   self.amp_strategy.get_white_list(), self.amp_strategy.get_black_list()):
+                with AmpDecorator(self.amp_strategy.get_amp_level(), self.amp_strategy.get_amp_dtype(),
+                                  self.amp_strategy.get_white_list(), self.amp_strategy.get_black_list()):
                     grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)
             else:
                 grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)
@@ -211,14 +211,12 @@ def _detach_input(input_arg):
 def _check_validation(block):
     if not isinstance(block, Cell):
         raise TypeError("Recompute function now only support block which inherited from Cell!")
-    if context.get_context("mode") != context.PYNATIVE_MODE:
-        raise AssertionError("Recompute function now only support pynative mode, you can use "
-                             "Cell.recompute() in graph mode.")
     if block.construct.__code__.co_name == "staging_specialize":
         logger.warning('Block\'s construct method decorated by @jit that recompute '
                        'function will not come into effect.')
 
 
+@jit_forbidden_register
 def recompute(block, *args, **kwargs):
     r"""
     This function is used to reduce memory, when run block, rather than

mindspore/common/sparse_tensor.py

@@ -98,7 +98,6 @@ class RowTensor(RowTensorInner):
 
     .. warning::
         - This is an experimental API that is subjected to change or deletion.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
 
     Args:
         indices (Tensor): A 1-D integer Tensor of shape :math:`(d_0)` . Default: ``None``.
@@ -232,7 +231,6 @@ class COOTensor(COOTensor_):
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - Currently, duplicate coordinates in the indices will not be coalesced.
           If the indices contain out-of-bound values, the result will be undefined.
 
@@ -681,7 +679,6 @@ class CSRTensor(CSRTensor_):
 
     .. warning::
         - This is an experimental API that is subjected to change.
-        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - If the values given by `indptr` or `indices` are invalid, the results may be undefined. Invalid values include
           when the length of `values` or `indices` exceeds the range indicated by `indptr`, and when the columns
           indicated by `indices` are repeated on the same row.

mindspore/common/symbol.py

@@ -104,7 +104,6 @@ class Symbol:
         if not isinstance(unique, bool):
             raise TypeError(f"For 'Symbol', the argument 'unique' must be bool, but got {type(unique)}")
 
-    # pylint: disable=missing-docstring
     def to_dict(self):
         # Convert the symbolic info to dictionary.
         # This method is not necessary to show in public api document, use comment instead of docstring.

mindspore/common/tensor.py

@@ -32,11 +32,12 @@ from mindspore.common.hook_handle import _TensorHookHandle
 from mindspore.common._utils import get_slice_num
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore._c_expression import TensorPy as TensorPy_
+from mindspore._c_expression import _rmod_instance
 from mindspore import _checkparam as validator
 from mindspore._checkparam import is_stub_tensor, check_hook_fn
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore.common.symbol import Symbol
-
+from mindspore._c_expression import is_reboot_node
 
 np_types = (np.int8, np.int16, np.int32, np.int64,
             np.uint8, np.uint16, np.uint32, np.uint64, np.float16,
@@ -93,13 +94,6 @@ def _set_symbolic_shape(shape):
     return shape, symbolic_shape
 
 
-def _convert_stub_tensor(input_data):
-    """Convert input to stub tensor"""
-    if not is_stub_tensor(input_data):
-        return input_data
-    return input_data.stub_sync()
-
-
 def _convert_numpy_array(input_data):
     """Convert inpyt to numpy array"""
     if not isinstance(input_data, np_types):
@@ -144,8 +138,6 @@ def _init(input_data=None, dtype=None, shape=None, init=None, const_arg=False, d
         _cast = tensor_operator_registry.get("cast")
         input_data = _cast(input_data, dtype)
 
-    input_data = _convert_stub_tensor(input_data)
-
     if input_data is None and shape is None and init is None and dtype is not None:
         validator.check_type_name('dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
         logger.warning(f"For 'Tensor', if 'dtype' is not None, 'input_data', 'shape' or 'init' must not be None.")
@@ -325,7 +317,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                 return True
         return NotImplemented
 
-
     def __deepcopy__(self, memodict):
         new_obj = Tensor(self)
         new_obj.init = self.init
@@ -379,9 +370,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         try:
             data = self._item()
             return int(data)
-        except ValueError:
-            raise ValueError("Only one element tensors can be converted to Python scalars")
-
+        except ValueError as e:
+            raise ValueError("Only one element tensors can be converted to Python scalars") from e
 
     def __float__(self):
         try:
@@ -396,8 +386,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             if not isinstance(data, (int, bool)):
                 raise ValueError
             return int(data)
-        except ValueError:
-            raise ValueError("Only integer tensors of a single element can be converted to an index.")
+        except ValueError as e:
+            raise ValueError("Only integer tensors of a single element can be converted to an index.") from e
 
     def __pos__(self):
         return self
@@ -426,14 +416,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
     def __rtruediv__(self, other):
         return tensor_operator_registry.get('__truediv__')(other, self)
 
-    def __mod__(self, other):
-        return tensor_operator_registry.get('__mod__')(self, other)
-
     def __rmod__(self, other):
-        return tensor_operator_registry.get('__mod__')(other, self)
-
-    def __imod__(self, other):
-        return self.__mod__(other)
+        return _rmod_instance(other, self)
 
     def __rpow__(self, other):
         return tensor_operator_registry.get('__rpow__')(self, other)
@@ -1163,7 +1147,6 @@ 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.
@@ -1868,6 +1851,10 @@ 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
@@ -2110,11 +2097,13 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
 
         from mindspore.common.initializer import Zero as ZeroInitializer
 
+        is_qint4x2 = self.dtype == mstype.qint4x2
         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(self.dtype))
+                data = np.zeros(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
             else:
-                data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+                data = np.ndarray(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
         except ValueError as e:
             msg = "Error shape={}".format(shape)
             logger.critical(msg)
@@ -2127,7 +2116,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                 self.init = init
                 global_seed = get_seed()
                 self._np_seed = np.random.get_state()[1][0]
-                self.need_set_seed = (slice_index is not None)
+                self.need_set_seed = slice_index is not None
                 self._global_seed = global_seed
                 self._seed_offset = 1
                 if self.need_set_seed:
@@ -2150,7 +2139,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            if not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1:
+            if (not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1) \
+                    and not is_reboot_node():
                 self.init(data)
         self.init = None
 
@@ -2159,6 +2149,10 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             self.assign_value(TensorPy_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
         else:
             self.assign_value(TensorPy_.from_numpy(data))
+
+        if is_qint4x2:
+            self.set_dtype(mstype.qint4x2)
+
         return self
 
     def resize(self, *new_shape):
@@ -2495,6 +2489,39 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('uniform_')(self, from_=from_, to=to, generator=generator)
 
+    def exponential_(self, lambd=1, *, generator=None):
+        r"""
+        Fills `self` tensor with elements drawn from the exponential distribution:
+
+        .. math::
+            f(x) = \lambda \exp(-\lambda x)
+
+        .. warning::
+            - It is only supported on Atlas A2 Training Series Products.
+            - This is an experimental API that is subject to change or deletion.
+
+        Args:
+            lambd (float, optional): Parameters of exponential distribution. Default: ``1``.
+
+        Keyword Args:
+            generator (Generator, optional): a pseudorandom number generator.
+                Default: ``None`` .
+
+        Returns:
+            Tensor, with same shape and same data type with input.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import mindspore
+            >>> x = mindspore.Tensor([1, 2, 3.0])
+            >>> out = x.exponential_(2)
+            >>> print(out.shape)
+            (3,)
+        """
+        return tensor_operator_registry.get('exponential_')(self, lambd=lambd, generator=generator)
+
     def sum_to_size(self, *size):
         r"""
         Sum self Tensor to the `size`. `size` must be expandable to the Tensor size.
@@ -2526,17 +2553,19 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         shape_x = x.shape
         if len(size) > x.ndim:
             raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
+        pre_len = 0
+        pre_axis = []
         if len(size) < x.ndim:
-            pre_axis = tuple([axis for axis in range(x.ndim - len(size))])
-            x = x.sum(pre_axis)
-        axes = []
+            pre_len = x.ndim - len(size)
+            pre_axis = [axis for axis in range(pre_len)]
+        axes = pre_axis
         for i, element in enumerate(size):
-            if element != x.shape[i] and element == 1:
-                axes.append(i)
-            elif element != x.shape[i]:
+            if element != x.shape[i + pre_len] and element == 1:
+                axes.append(i + pre_len)
+            elif element != x.shape[i + pre_len]:
                 raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
         if axes:
-            return x.sum(tuple(axes), keepdims=True)
+            return x.sum(tuple(axes), keepdims=True).reshape(size)
         return x
 
     def nanmean(self, axis=None, keepdims=False, *, dtype=None):
@@ -2557,6 +2586,34 @@ 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
@@ -2619,7 +2676,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         Note:
            The rank of `self`.
 
-           - Ascend: its rank can be equal to 0 except O2 mode.
+           - Ascend: its rank can be equal to 0 except GE backend.
            - CPU/GPU: its rank should be greater than or eaqual to 1.
 
         Keyword Args:
@@ -2638,7 +2695,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         Raises:
             TypeError: If `self` is not Tensor.
             TypeError: If `as_tuple` is not bool.
-            RuntimeError: On GPU or CPU or Ascend O2 mode, if dim of `input` equals to 0.
+            RuntimeError: On GPU or CPU or Ascend GE backend, if dim of `input` equals to 0.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -2801,7 +2858,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return []
         return self._tolist()
 
-
     def unsorted_segment_min(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_min`.
@@ -2824,7 +2880,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.unique_consecutive`.
         """
-        output, idx, counts =\
+        output, idx, counts = \
             tensor_operator_registry.get("unique_consecutive")(return_inverse, return_counts, dim)(self)
         if return_inverse and return_counts:
             return output, idx, counts
@@ -2911,7 +2967,8 @@ 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): The valid data type of the output tensor. Only constant value is allowed.
+            dtype (dtype.Number, bool): The valid data type of the output tensor. Only constant value is allowed.
+                Only Support type bool in PyNative mode.
 
         Returns:
             Tensor, converted to the specified `dtype`.
@@ -2963,7 +3020,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return str(self.dtype)
         return self.astype(dtype)
 
-
     def type_as(self, other):
         r"""
         Returns self tensor cast to the type of the with the input other tensor.
@@ -3006,7 +3062,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return self
         return TensorPy_.type_as(self, other)
 
-
     def bool(self):
         r"""
         Converts input tensor dtype to `bool`.
@@ -3502,49 +3557,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('zero_')(self)
 
-    def new_empty(self, size, *, dtype=None, device=None):
-        r"""
-        Returns an uninitialized Tensor of `size`. Its dtype is specified by `dtype` and its
-        device is specified by `device`.
-
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-
-        Args:
-            size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Only positive integer or
-                tuple or list containing positive integers are allowed.
-
-        Keyword Args:
-            dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`,
-                the tensor will have the same dtype as `self`. Default ``None``.
-            device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
-                `device = None`, the tensor will have the same device as `self` and if the device of `self` is not
-                defined, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
-
-        Returns:
-            Tensor, the shape, dtype and device is defined above but with uninitialized data (May be a random value).
-
-        Raises:
-            TypeError: If `size` is neither an int nor a tuple or list of int.
-
-        Supported Platforms:
-            ``Ascend``
-
-        Examples:
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
-            >>> output1 = x.new_empty((2, 3))
-            >>> print(output1)
-            [[0 0 0]
-             [0 0 0]]
-            >>> output2 = x.new_empty((2, 3), dtype=mindspore.float64)
-            >>> print(output2)
-            [[0. 0. 0.]
-             [0. 0. 0.]]
-        """
-        return tensor_operator_registry.get('new_empty')(self, size, dtype, device)
-
     def sign(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sign`.
@@ -3616,46 +3628,6 @@ 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`
@@ -3796,9 +3768,6 @@ 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):
@@ -3833,6 +3802,23 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return TensorPy_._data_ptr(self)
 
+    def data_ptr(self):
+        r"""
+        Get the data ptr address of tensor, for CPU is host address, GPU/NPU is device address.
+        User should know how to use the data ptr address.
+        Note: this api is an experimental api, users need understatnd it before use.
+
+        Supported Platforms:
+            ``CPU/GPU/Ascend``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int64)
+            >>> data_ptr = x.data_ptr()
+        """
+        return TensorPy_._data_ptr(self)
+
     def normal_(self, mean=0, std=1, *, generator=None):
         r"""
         Update the `self` tensor in place by generating random numbers sampled from the normal
@@ -3872,13 +3858,13 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('normal_')(self, mean=mean, std=std, generator=generator)
 
-
     def triangular_solve(self, A, upper=True, transpose=False, unitriangular=False):
         r"""
         For details, please refer to :func:`mindspore.mint.triangular_solve`.
         """
         return tensor_operator_registry.get('triangular_solve')(self, A, upper, transpose, unitriangular)
 
+
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
     if args:
@@ -3951,9 +3937,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()))
+        dtype = mstype._pytype_to_dtype(np.dtype(dtype.lower()))  # pylint:disable=protected-access
     elif isinstance(dtype, type):
-        dtype = mstype.pytype_to_dtype(dtype)
+        dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
     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/_comm_helper.py

@@ -25,7 +25,7 @@ from mindspore import context
 from mindspore.parallel._ps_context import _is_role_sched, _is_ps_mode,\
                                            _get_ps_context
 from mindspore import log as logger
-from mindspore._c_expression import CollectiveManager, set_cluster_exit_with_exception, MSContext
+from mindspore._c_expression import CollectiveManager, set_cluster_exit_with_exception, MSContext, GroupOptions
 from mindspore.common._utils import load_lib
 
 HCCL_LIB = 'libhccl_plugin.so'
@@ -470,14 +470,25 @@ def _get_group_ranks(group):
 
 
 @check_parameter_available
-def _create_group_helper(group, rank_ids):
+def _create_group_helper(group, rank_ids, options=None):
     """
     The Helper to do create_group.
 
     Args:
         group (str): The communication group.
         rank_ids (list): Rank ids in the group.
-        backend (str): The backend, like "hccl".
+        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 rank_ids is not a list.
@@ -499,10 +510,15 @@ def _create_group_helper(group, rank_ids):
                          "but got 'rank_ids' size : {}.".format(len(rank_ids)))
     if len(rank_ids) - len(list(set(rank_ids))) > 0:
         raise ValueError("List rank_ids in Group {} has duplicate data!".format(group))
+    if options is None:
+        options = GroupOptions()
+    if not isinstance(options, GroupOptions):
+        raise TypeError("For 'create_group', the argument 'options' must be type of GroupOptions, "
+                        "but got 'options' type : {}.".format(type(options)))
     if _hccl_test():
         hccl.create_group(group, rank_size, rank_ids)
     else:
-        result = CollectiveManager.get_instance().create_group(group, rank_ids)
+        result = CollectiveManager.get_instance().create_group(group, rank_ids, options)
         if not result:
             raise RuntimeError("Failed to create communication group for {} with rank ids {}. "
                                "If NCCL is used, 'export NCCL_DEBUG=INFO' "
@@ -554,3 +570,29 @@ def _get_group_map():
 def _wait_all_comm_init():
     """Wait for all communicators to be initialized."""
     return CollectiveManager.get_instance().wait_all_comm_init()
+
+
+def _remove_group_info(group_name):
+    """
+    Remove group info after destroy group by user when using arf.
+
+    Args:
+        group_name (str): The user communication group name.
+
+    """
+    CollectiveManager.get_instance().remove_group_info(group_name)
+
+
+def _comm_switch_nic_helper(global_ranks: list, use_backup: list) -> bool:
+    """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.
+    """
+    return CollectiveManager.get_instance().comm_switch_nic(global_ranks, use_backup)