mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.1__cp39-cp39-win_amd64.whl

mindspore/common/tensor.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -31,6 +31,8 @@ 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.common._tensor_overload import (repeat_interleave_mint, add_mint, item_mint, isnan_mint, flatten_mint,
+                                               max_mint, mean_mint, min_mint, split_mint, sub_mint)
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore import _checkparam as validator
 from mindspore._checkparam import check_is_number, is_stub_tensor, check_hook_fn
@@ -51,7 +53,7 @@ def _check_input_data_type(input_data):
                     np.float16, np.float32, np.float64, np.bool_, np.str_, np.complex64, np.complex128)
     if isinstance(input_data, np.ndarray) and input_data.dtype not in valid_dtypes and \
             input_data.dtype.kind != 'U' and input_data.dtype.kind != 'S' and \
-            input_data.dtype.kind != 'T':  # Support dtype np.str_ and npy_bfloat16
+            not (input_data.dtype.kind == 'V' and input_data.dtype.char == 'E'):  # Support np.str_ and np.bfloat16
         new_line = '\n'
         for index, x in np.ndenumerate(input_data):
             if np.array(x).dtype not in valid_dtypes:
@@ -85,11 +87,11 @@ def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, c
     based on the `dtype` argument.
 
     Please refer to `Creating and Using Tensor
-    <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#mindspore-user-defined-data-types>`_ .
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#mindspore-user-defined-data-types>`_ .
 
     The difference between it and the Tensor class is that it adds
     `Annotation
-    <https://www.mindspore.cn/docs/en/master/design/dynamic_graph_and_static_graph.html?#annotation-type>`_
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#annotation-type>`_
     which can prevent the generation of AnyType compared to the Tensor class.
 
     The arguments and return values are the same as the Tensor class. Also see: :class:`mindspore.Tensor`.
@@ -143,6 +145,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             Default: ``False`` .
         const_arg (bool): Whether the tensor is a constant when it is used for the argument of a network.
             Default: ``False`` .
+        device(str): This parameter is reserved and does not need to be configured.
+            Default: ``None`` .
 
     Outputs:
         Tensor.
@@ -205,7 +209,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     delta_seed = 0
 
-    def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False):
+    def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False,
+                 device=None):
         self.init_finished = False
         if isinstance(input_data, (Tensor, Tensor_)) and dtype is not None:
             logger.info("It is suggested to use 'Tensor.astype()' to convert the dtype of a Tensor.")
@@ -264,6 +269,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                         Tensor_.__init__(self, input_data)
                     validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
 
+        if device is not None and device != "CPU":
+            raise ValueError(f"Only 'CPU' is supported for device, but got {device}.")
+
         self.const_arg = const_arg
         self.virtual_flag = False
         self.init = init
@@ -380,6 +388,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __abs__(self):
         return tensor_operator_registry.get('abs')(self)
 
+    @add_mint
     def __add__(self, other):
         return tensor_operator_registry.get('__add__')(self, other)
 
@@ -404,6 +413,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __iadd__(self, other):
         return self.__add__(other)
 
+    @sub_mint
     def __sub__(self, other):
         return tensor_operator_registry.get('__sub__')(self, other)
 
@@ -513,9 +523,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return state
 
     def __setstate__(self, state):
-        value = state.pop("value")
+        if isinstance(state, tuple):
+            value = state
+        else:
+            value = state.pop("value")
+            self.__dict__.update(state)
         Tensor_.__setstate__(self, value)
-        self.__dict__.update(state)
 
     @property
     def shape(self):
@@ -706,8 +719,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Examples:
             >>> from mindspore import Tensor
+            >>> from mindspore import dtype as mstype
             >>> import numpy as np
-            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]), dtype=mstype.int64)
             >>> output = x.strides
             >>> print(output)
             (16, 8)
@@ -940,6 +954,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('chunk')(self, chunks, axis)
 
+    @item_mint
     def item(self, index=None):
         """
         Get the item at the specified index of the tensor.
@@ -1054,7 +1069,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.init_data()
         return Tensor_.asnumpy(self)
 
-    def numpy(self):
+    def numpy(self, *, force=False):
         """
         Alias for :func:`mindspore.Tensor.asnumpy`.
         """
@@ -1295,12 +1310,48 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('addcmul')(self, tensor1, tensor2, value)
 
+    @add_mint
     def add(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.add`.
         """
         return tensor_operator_registry.get('add')(self, other)
 
+    def add_(self, other, *, alpha=1):
+        """
+        inplace update self by following compute:
+            self = self + other * alpha.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+            The `other` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
+
+        Args:
+            other (Tensor): the source tensor Add to self Tensor.
+            alpha (Number): no effect currently.
+
+        Returns:
+            Return self Tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> a = Tensor(np.ones((2,3)).astype("float32"))
+            >>> b = Tensor(np.ones((2,3)).astype("float32"))
+            >>> a.add_(b)
+            >>> print(a)
+            [[2. 2. 2.]
+            [2. 2. 2.]]
+        """
+        if isinstance(other, (int, float)):
+            ret = tensor_operator_registry.get("adds_")(self, other, alpha)
+        else:
+            ret = tensor_operator_registry.get("add_")(self, other, alpha)
+        return ret
+
     def subtract(self, other, *, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.subtract`.
@@ -1337,6 +1388,19 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('addmm')(self, mat1, mat2, beta=beta, alpha=alpha)
 
+    def addmm_(self, mat1, mat2, *, beta=1, alpha=1):
+        r"""
+        For details, please refer to :func:`mindspore.ops.addmm`.
+
+        .. note::
+            The output results are directly updated in the Tensor.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        """
+        return tensor_operator_registry.get('addmm_')(self, mat1, mat2, beta=beta, alpha=alpha)
+
     def addr(self, vec1, vec2, beta=1, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addr`.
@@ -1579,6 +1643,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('square')(self)
 
+    @sub_mint
     def sub(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.sub`.
@@ -1842,6 +1907,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('log2')(self)
 
+    @mean_mint
     def mean(self, axis=None, keep_dims=False):
         """
         For details, please refer to :func:`mindspore.ops.mean`.
@@ -2012,11 +2078,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
-    def round(self):
+    def round(self, decimals=0):
         """
         For details, please refer to :func:`mindspore.ops.round`.
         """
-        return tensor_operator_registry.get('round')(self)
+        return tensor_operator_registry.get('round')(self, decimals=decimals)
 
     def roll(self, shifts, dims):
         """
@@ -2091,6 +2157,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('remainder')(self, divisor)
 
+    @flatten_mint
     def flatten(self, order='C', *, start_dim=0, end_dim=-1):
         r"""
         For details, please refer to :func:`mindspore.ops.flatten`.
@@ -2399,6 +2466,38 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         x = x.astype(origin_dtype)
         return x
 
+    def copy_(self, src, non_blocking=False):
+        """
+        Copies the elements from src into self tensor and returns self.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+            The `src` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
+
+        Args:
+            src (Tensor): the source tensor to copy from.
+            non_blocking (bool): no effect currently.
+
+        Returns:
+            Return self Tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> a = Tensor(np.ones((3,3)).astype("float32"))
+            >>> b = Tensor(np.zeros((3,3)).astype("float32"))
+            >>> a.copy_(b)
+            >>> print(a)
+            [[0. 0. 0.]
+            [0. 0. 0.]
+            [0. 0. 0.]]
+        """
+        return tensor_operator_registry.get("copy_")(self, src)
+
+    @max_mint
     def max(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
         Return the maximum of a tensor or maximum along an axis.
@@ -2467,6 +2566,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             return values
         return values, indices
 
+    @min_mint
     def min(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
         Return the minimum of a tensor or minimum along an axis.
@@ -2763,7 +2863,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
                 to get one shard of a parameter's slice. For more information about optimizer parallel, please refer to:
                 `Optimizer Parallel
-                <https://www.mindspore.cn/tutorials/experts/en/master/parallel/optimizer_parallel.html>`_.
+                <https://www.mindspore.cn/docs/en/master/model_train/parallel/optimizer_parallel.html>`_.
                 Default: ``None``.
 
         Returns:
@@ -2796,8 +2896,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.slice_shape_of_persistent_data_ = data_shape
             self.slice_num_of_persistent_data_ = slice_num_of_persistent_data
 
+        from mindspore.common.initializer import Zero as ZeroInitializer
+
         try:
-            data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+            if isinstance(self.init, ZeroInitializer):
+                data = np.zeros(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+            else:
+                data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
         except ValueError as e:
             msg = "Error shape={}".format(shape)
             logger.critical(msg)
@@ -2833,7 +2938,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            if slice_num_of_persistent_data == 1:
+            if not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1:
                 self.init(data)
         self.init = None
 
@@ -2995,16 +3100,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.trace())
             3.0
         """
-        if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
-            return tensor_operator_registry.get('trace')(self)
-        d = self.diagonal(offset, axis1=axis1, axis2=axis2)
-        shape = d.shape
-        if dtype is None:
-            dtype = d.dtype
-        if shape[-1] == 0:
-            return tensor_operator_registry.get('fill')(dtype, shape[:-1], 0)
-        res = tensor_operator_registry.get('reduce_sum')(d.astype(mstype.float32), -1)
-        return res.astype(dtype)
+        return tensor_operator_registry.get('tracev2')(self, offset, axis1, axis2, dtype)
 
     def take(self, indices, axis=None, mode='clip'):
         """
@@ -3164,6 +3260,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             sorter (Union[int, list, tuple, Tensor]): optional tensor of
                 integer indices that sort the tensor into ascending order on the innermost dimension
                 and the type must be int64. They are typically the result of argsort. Default: ``None`` .
+                CPU and GPU can only use default values
 
         Returns:
             Tensor, array of insertion points with the same shape as `v`.
@@ -3217,10 +3314,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def uniform(self, from_=0., to=1., generator=None):
         r"""
-        Generates random numbers in the half-open interval [from_, to).
+        Generates random numbers in the half-open interval [from\_, to).
 
         Args:
-            from_ (number): The lower bound of the interval.
+            from\_ (number): The lower bound of the interval.
             to (number): The upper bound of the interval.
             generator (Generator, optional): The random seed. Default: None.
 
@@ -3506,6 +3603,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 repeated_subs.append(tensor_operator_registry.get('repeat_elements')(sub, rep, axis))
         return tensor_operator_registry.get('concatenate')(repeated_subs, axis)
 
+    @repeat_interleave_mint
     def repeat_interleave(self, repeats, dim=None):
         """
         For details, please refer to :func:`mindspore.ops.repeat_interleave`.
@@ -3740,6 +3838,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("xdivy")(self, y)
 
+    @split_mint
     def split(self, split_size_or_sections, axis=0):
         """
         For details, please refer to :func:`mindspore.ops.split`.
@@ -4039,6 +4138,27 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('int')(self, mstype.int32)
 
+    def byte(self):
+        r"""
+        Converts input tensor dtype to `uint8`.
+
+        Returns:
+            Tensor, converted to the `uint8` dtype.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> input_x = Tensor(np.ones([2,2]), mindspore.float32)
+            >>> output = input_x.byte()
+            >>> print(output.dtype)
+            uint8
+        """
+        return tensor_operator_registry.get('byte')(self, mstype.uint8)
+
     def long(self):
         r"""
         Converts input tensor dtype to `int64`. If the value in tensor is float or half, the decimal will be discarded.
@@ -4249,6 +4369,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('isinf')(self)
 
+    @isnan_mint
     def isnan(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isnan`.
@@ -4425,7 +4546,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('mul')(self, value)
 
-    def nan_to_num(self, nan=0.0, posinf=None, neginf=None):
+    def nan_to_num(self, nan=None, posinf=None, neginf=None):
         """
         For details, please refer to :func:`mindspore.ops.nan_to_num`.
         """
@@ -4482,6 +4603,31 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('zeros')(size, dtype)
 
+    def zero_(self):
+        r"""
+        Return a tensor filled with zeros.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Returns:
+            Return a tensor. Fill self tensor with zeros.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([2, 2]))
+            >>> output = x.zero_()
+            >>> print(output)
+            [[0. 0.]
+             [0. 0.]]
+        """
+        return tensor_operator_registry.get('zero_')(self)
+
     def new_ones(self, size, dtype=None):
         r"""
         Return a tensor of `size` filled with ones.
@@ -4608,7 +4754,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('lu_solve')(self, LU_data, LU_pivots)
 
-
     def nextafter(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.nextafter`.
@@ -4622,7 +4767,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_value_type('some', some, bool, 'Tensor.qr')
         return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
 
-
     def ormqr(self, input2, input3, left=True, transpose=False):
         r"""
         For details, please refer to :func:`mindspore.ops.ormqr`,
@@ -4630,7 +4774,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('ormqr')(self, input2, input3, left, transpose)
 
-
     def masked_scatter(self, mask, x):
         r"""
         Returns a Tensor. Updates the value in the "self Tensor" with the `tensor` value according to the mask.
@@ -4671,7 +4814,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
 
-
     def index_put(self, indices, values, accumulate=False):
         r"""
         Returns a Tensor. According to the index number of `indices` ,
@@ -4724,7 +4866,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         _index_put = tensor_operator_registry.get('index_put')(0 if accumulate is False else 1)
         return _index_put(self, values, indices)
 
-
     def move_to(self, to, blocking=True):
         r"""
         Copy Tensor to target device synchronously or asynchronously, default synchronously. only support PyNative mode.
@@ -4758,8 +4899,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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 Tensor(Tensor_.move_to(self, to, blocking))
-
+        return Tensor_.move_to(self, to, blocking)
 
     def _offload(self):
         r"""
@@ -4817,9 +4957,15 @@ def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
     if input_data is not None:
         if isinstance(input_data, np.ndarray) and input_data.ndim >= 1 and input_data.size == 0:
             raise ValueError("input_data can not contain zero dimension.")
-        if isinstance(input_data, (tuple, list)) and np.array(input_data).ndim >= 1 \
-                and np.array(input_data).size == 0:
-            raise ValueError("input_data can not contain zero dimension.")
+        if isinstance(input_data, (tuple, list)):
+            try:
+                np_data = np.array(input_data)
+            except ValueError as e:
+                if "The requested array has an inhomogeneous shape" in str(e):
+                    raise TypeError(f"For Tensor, the input_data is {input_data} that contain unsupported element.")
+                raise
+            if np_data.ndim >= 1 and np_data.size == 0:
+                raise ValueError("input_data can not contain zero dimension.")
 
     if shape is not None and not (hasattr(init, "__enable_zero_dim__") and init.__enable_zero_dim__) and 0 in shape:
         raise ValueError("Shape can not contain zero value.")

mindspore/communication/__init__.py

@@ -20,7 +20,7 @@ Note that the APIs in the following list need to preset communication environmen
 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/experts/zh-CN/master/parallel/msrun_launcher.html>`_
+<https://www.mindspore.cn/docs/zh-CN/master/model_train/parallel/msrun_launcher.html>`_
 for more details.
 """
 

mindspore/communication/_comm_helper.py

@@ -22,7 +22,7 @@ import sys
 from sys import excepthook
 
 from mindspore import context
-from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver, _is_role_sched, _is_ps_mode,\
+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
@@ -127,6 +127,7 @@ class _ExistingGroup:
     The communication groups which exist in the progress.
     """
     ITEMS = {}
+    GROUP_RANKS = {}
 
 
 def _hccl_test():
@@ -160,8 +161,7 @@ def _check_bypass_rank_id_and_size():
 
 
 def _set_elegant_exit_handle():
-    if _is_role_worker() or _is_role_pserver() or _is_role_sched():
-        sys.excepthook = lambda *args: (set_cluster_exit_with_exception(), excepthook(*args))
+    sys.excepthook = lambda *args: (set_cluster_exit_with_exception(), excepthook(*args))
 
 
 def check_parameter_available(func):
@@ -390,6 +390,38 @@ def _get_group_rank_from_world_rank_helper(world_rank_id, group):
     return group_rank_id
 
 
+@check_parameter_available
+def _get_group_rank_from_world_rank_from_cache_helper(world_rank_id, group):
+    """
+    The Helper to do get_group_rank_from_world_rank_from_cache.
+
+    Args:
+        world_rank_id (int): A rank id in world communication group.
+        group (str): The user communication group.
+
+    Raises:
+        TypeError: If world_rank_id is not int.
+        KeyError: If group and world_rank_id is not found in cache.
+
+    Returns:
+        Integer. A rank id in user communication group.
+    """
+    if not isinstance(world_rank_id, int):
+        raise TypeError("For 'get_group_rank_from_world_rank_from_cache', the argument 'world_rank_id' must be type of "
+                        "int, but got 'world_rank_id' type : {}.".format(type(world_rank_id)))
+
+    if group == GlobalComm.WORLD_COMM_GROUP:
+        # world_rank_id is same with group_rank_id in WORLD_COMM_GROUP
+        return world_rank_id
+    if group not in _ExistingGroup.GROUP_RANKS:
+        raise KeyError("For 'get_group_rank_from_world_rank_from_cache', the argument 'group' is not "
+                       "found in GROUP_RANKS, 'group' : {}, 'world_rank_id' : {}".format(group, world_rank_id))
+    if world_rank_id not in _ExistingGroup.GROUP_RANKS[group]:
+        raise KeyError("For 'get_group_rank_from_world_rank_from_cache', the argument 'world_rank_id' is not "
+                       "found in GROUP_RANKS, 'group' : {}, 'world_rank_id' : {}".format(group, world_rank_id))
+    return _ExistingGroup.GROUP_RANKS[group][world_rank_id]
+
+
 @check_parameter_available
 def _get_group_ranks(group):
     """
@@ -444,6 +476,9 @@ def _create_group_helper(group, rank_ids):
                                "is suggested before launching jobs.".format(group, rank_ids))
 
     _ExistingGroup.ITEMS[group] = rank_ids
+    sorted_ranks = sorted(rank_ids)
+    _ExistingGroup.GROUP_RANKS[group] = {world_rank_id: group_rank_id
+                                         for group_rank_id, world_rank_id in enumerate(sorted_ranks)}
 
 
 @check_parameter_available