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

mindspore/ops/auto_generate/gen_ops_def.py

@@ -250,11 +250,11 @@ def add_ext(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -312,7 +312,7 @@ def add(input, other):
 
     Note:
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
         - Support broadcast, support implicit type conversion and type promotion.
         - When the input is a tensor, the dimension should be greater than or equal to 1.
 
@@ -442,8 +442,7 @@ def apply_rotary_pos_emb_(query, key, cos, sin, position_ids, cos_format=0):
     r"""
     
     """
-    apply_rotary_pos_emb_op = _get_cache_prim(ApplyRotaryPosEmb)(cos_format)
-    return apply_rotary_pos_emb_op(query, key, cos, sin, position_ids)
+    return apply_rotary_pos_emb_impl(query, key, cos, sin, position_ids, cos_format)
 
 
 def argmax_ext(input, dim=None, keepdim=False):
@@ -1183,7 +1182,7 @@ def broadcast_to(input, shape):
 
     Args:
         input (Tensor): The input tensor.
-        shape (tuple): The target shape.
+        shape (tuple[int]): The target shape.
 
     Returns:
         Tensor
@@ -1827,7 +1826,7 @@ def correlate(a, v, pad_mode='valid'):
 
     Note:
         - `correlate` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `correlate` is not supported on Windows platform yet.
 
     Args:
@@ -1986,6 +1985,112 @@ def count_nonzero(input, dim=None):
     return count_nonzero_op(input, dim)
 
 
+def cross_entropy_loss_grad(grad_loss, log_prob, target, weight=None, grad_zloss=None, lse_for_zloss=None, reduction='mean', ignore_index=-100, label_smoothing=0.0, lse_square_scale_for_zloss=0.0):
+    r"""
+    
+    """
+    return cross_entropy_loss_grad_op(grad_loss, log_prob, target, weight, grad_zloss, lse_for_zloss, reduction, ignore_index, label_smoothing, lse_square_scale_for_zloss)
+
+
+def cross_entropy_loss(input, target, weight=None, reduction='mean', ignore_index=-100, label_smoothing=0.0, lse_square_scale_for_zloss=0.0, return_zloss=False):
+    r"""
+    Computes the cross entropy loss between input and target.
+
+    Assume the number of classes :math:`C` in the range :math:`[0, C)`,
+    the loss with reduction=none can be described as:
+
+    .. math::
+
+        \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad
+        l_n = - w_{y_n} \log \frac{\exp(x_{n,y_n})}{\sum_{c=1}^C \exp(x_{n,c})}
+        \cdot \mathbb{1}\{y_n \not= \text{ignore_index}\}
+
+    where :math:`x` is the inputs, :math:`y` is the target, :math:`w` is the weight, :math:`N` is the batch size,
+    :math:`c` belonging to :math:`[0, C-1]` is class index, where :math:`C` is the number of classes.
+
+    If `reduction` is not ``None`` (default ``'mean'`` ), then
+
+    .. math::
+
+        \ell(x, y) = \begin{cases}
+            \sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{y_n} \cdot \mathbb{1}\{y_n \not= \text{ignore_index}\}} l_n, &
+            \text{if reduction} = \text{'mean',}\\
+            \sum_{n=1}^N l_n,  &
+            \text{if reduction} = \text{'sum'.}
+            \end{cases}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **input** (Tensor) - Tensor of shape of :math:`(N, C)` where `C = number of classes`, data type must be bfloat16, float16 or float32.
+        - **target** (Tensor) - For class indices, tensor of shape :math:`(N)`, data type must be int64. The value must be in range [0, C).
+        - **weight** (Tensor, optional) - A rescaling weight applied to the loss of each batch element.
+          If not None, the shape is :math:`(C,)`, data type must be float32. Default: ``None`` .
+        - **reduction** (str, optional) - Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+          ``'sum'`` . Default: ``'mean'`` .
+
+          - ``'none'``: no reduction will be applied.
+          - ``'mean'``: compute and return the weighted mean of elements in the output.
+          - ``'sum'``: the output elements will be summed.
+
+        - **ignore_index** (int, optional) - Specifies a target value that is ignored and does not contribute to the input
+          gradient. When set to negative values, no target value is ignored. It should be int64.
+          Default: ``-100`` .
+        - **label_smoothing** (float, optional) - Label smoothing values, a regularization tool used to prevent the model
+          from overfitting when calculating Loss. This value must be 0.0 currently. Default: ``0.0`` .
+        - **lse_square_scale_for_zloss** (float, optional) - The value range is [0.0, 1.0), not enabled for now, can only be 0.0. Default: ``0.0`` .
+        - **return_zloss** (float, optional) - Not enabled for now, can only be ``False``. Default: ``False`` .
+
+    Outputs:
+        A tuple consisting of 4 Tensors.
+
+        - **loss** (Tensor) - loss between `input` and `target`, the dtype is the same as `input`.
+
+          - If `reduction` is ``'none'`` , the shape is :math:`(N,)` .
+          - If `reduction` is ``'sum'` or ``'mean'`, the shape is :math:`(1,)` .
+
+        - **log_prob** (Tensor) - the shape is :math:`(N, C)` with the same dtype as `input`.
+        - **zloss** (Tensor) - the shape is :math:`(N,)` if `return_zloss` is True, or the shape is :math:`(0,)` with the same dtype as `input`. This parameter is disabled for now.
+        - **lse_for_zloss** (Tensor) - the shape is :math:`(N,)` if `lse_square_scale_for_zloss` is not 0.0, or the shape is :math:`(0,)` with the same dtype as `input`. This parameter is disabled for now.
+
+
+    Raises:
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
+        TypeError: If `input`, `target` or `weight` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn, ops
+        >>> 
+        >>> 
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.cross_entropy_loss = ops.auto_generate.CrossEntropyLoss()
+        ... 
+        ...     def construct(self, input, target, weight):
+        ...         result = self.cross_entropy_loss(input, target, weight)
+        ...         return result
+        ... 
+        >>> 
+        >>> net = Net()
+        >>> input = Tensor(np.array([[0.2, 0.7, 0.1], [0.2, 0.7, 0.1]]), mindspore.float32)
+        >>> target = Tensor(np.array([0, 1]), mindspore.int64)
+        >>> weight = Tensor(np.array([1, 0.5, 0.5]), mindspore.float32)
+        >>> output = net(input, target, weight)
+        >>> print(output[:2])
+        (Tensor(shape=[1], dtype=Float32, value= [ 1.10128295e+00]), Tensor(shape=[2, 3], dtype=Float32, value=
+        [[-1.26794958e+00, -7.67949641e-01, -1.36794960e+00],
+         [-1.26794958e+00, -7.67949641e-01, -1.36794960e+00]]))
+    """
+    return cross_entropy_loss_op(input, target, weight, reduction, ignore_index, label_smoothing, lse_square_scale_for_zloss, return_zloss)
+
+
 def cummax(input, axis):
     r"""
     Return the cumulative maximum values and their indices along the given axis of the tensor.
@@ -2037,7 +2142,7 @@ def cummin_ext(input, dim):
         \end{array}
 
     .. note::
-        O2 mode is not supported in Ascend.
+        GE backend is not supported in Ascend.
 
     Args:
         input (Tensor): The input Tensor, The dimension must be greater than 0.
@@ -2117,61 +2222,6 @@ def cumsum_ext(input, dim, dtype=None):
     return cumsum_ext_op(input, dim, dtype)
 
 
-def decoder_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len):
-    r"""
-    The DecoderKVCache is used for decoding the KVCache of transformer network.
-
-    Args:
-        cache (Tensor): The cahe tensor with data type of int8, uint8, int16, uint16, float16, float32 and int32.
-          When format is BHSD, cache tensor of shape
-          :math:`(batch\_size, num\_head, max\_seq\_length, size\_pre\_head)`.
-          When format is BSD, cache tensor of shape
-          :math:`(batch\_size, max\_seq\_length, hidden\_size)`.
-        update (Tensor]): The tensor which is used to update the cache tensor. Same data type as cache tensor.
-          When format is BHSD, update tensor of shape
-          :math:`(batch\_size, num\_head, update\_seq\_length, size\_pre\_head)`.
-          When format is BSD, update tensor of shape
-          :math:`(batch\_size, update\_seq\_length, hidden\_size)`.
-        valid_seq_len (Tensor): The valid_seq_len tensor with data type of int64.
-          Valid_seq_len tensor of shape :math:`(batch\_size)`.
-        batch_index (Tensor): The batch_index tensor with data type of int64.
-          Batch_index tensor of shape :math:`(batch\_size)`. Indicate that which batch of cache tensor is going to be update. Not abel for now.
-        seq_len_axis (Tensor): The seq_len_axis indicate which axis is seq_eln, set to '1' or '2'. Not able for now.
-        new_max_seq_len (Tensor): The new_max_seq_len tensor with data type of int64.
-          New_max_seq_len tensor of shape :math:`(1)`.
-          Indicate that user want to change the shape of cache tensor from
-          :math:`(batch\_size, num_head, max\_seq\_length, hidden\_size)`. to
-          :math:`(batch\_size * max\_seq\_length / new\_max\_seq\_length, num_head, new\_max\_seq\_length, hidden\_size)`.
-          to update the cache tensor. This will not real change the shape of `cache` tensor.
-        cur_max_seq_len (Tensor): The new_max_seq_len tensor with data type of int64.
-          Cur_max_seq_len tensor of shape :math:`(1)`. Keep the current seq_len of cache tensor. Not abel for now.
-
-    Outputs:
-        With same data type and same shape as `cache` tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore.ops.operations import _inner_ops
-        >>> b = 4
-        >>> h = 40
-        >>> max_s = 1024
-        >>> s = 1
-        >>> d = 128
-        >>> cache = Tensor(np.random.randn(b, h, max_s, d).astype(np.float16))
-        >>> update = Tensor(np.random.randn(b, h, s, d).astype(np.float16))
-        >>> valid_seq_len = Tensor(np.random.randint(-1, s, size=b).astype(np.int64))
-        >>> batch_index = Tensor(np.random.choice(np.arange(-1, b), size=b, replace=False).astype(np.int64))
-        >>> new_max_seq_len = Tensor(np.random.randn(1).astype(np.int64))
-        >>> cur_max_seq_len = Tensor(np.random.randn(1).astype(np.int64))
-        >>> decoder_kv_cache = _inner_ops.DecoderKVCache()
-        >>> output = decoder_kv_cache(cache, update, valid_seq_len, batch_index, Tensor(2), new_max_seq_len, cur_max_seq_len)
-        >>> print(cache)
-    """
-    return decoder_k_v_cache_op(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len)
-
-
 def dense(input, weight, bias=None):
     r"""
     Applies the dense connected operation to the `input`. The dense function is defined as:
@@ -3053,7 +3103,7 @@ def fft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `fft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `fft2` is not supported on Windows platform yet.
 
     Args:
@@ -3117,7 +3167,7 @@ def fftfreq(n, d=1.0, dtype=None):
 
     Note:
         - `fftfreq` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `fftfreq` is not supported on Windows platform yet.
 
     Args:
@@ -3150,7 +3200,7 @@ def fftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `fftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `fftn` is not supported on Windows platform yet.
 
     Args:
@@ -3210,7 +3260,7 @@ def fftshift(input, dim=None):
 
     Note:
         - `fftshift` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `fftshift` is not supported on Windows platform yet.
 
     Args:
@@ -3246,7 +3296,7 @@ def fft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `fft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `fft` is not supported on Windows platform yet.
 
     Args:
@@ -3505,11 +3555,11 @@ def frac_ext(input):
     return frac_op(input)
 
 
-def fused_add_topk_div(x, add_num, group_num, group_topk, n, k, activate_type=0, is_norm=True, scale=2.5):
+def fused_add_topk_div(x, add_num, group_num, group_topk, n, k, activate_type=0, is_norm=True, scale=2.5, mapping_num=None, mapping_table=None, enable_expert_mapping=False):
     r"""
     
     """
-    return fused_add_topk_div_op(x, add_num, group_num, group_topk, n, k, activate_type, is_norm, scale)
+    return fused_add_topk_div_op(x, add_num, group_num, group_topk, n, k, activate_type, is_norm, scale, mapping_num, mapping_table, enable_expert_mapping)
 
 
 def gather_d(x, dim, index):
@@ -3582,7 +3632,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
         - The value of input_indices must be in the range of `[0, input_param.shape[axis])`.
           On CPU and GPU, an error is raised if an out of bound indice is found. On Ascend, the results may be
           undefined.
-        - The data type of input_params cannot be `mindspore.bool_` .
+        - The data type of input_params cannot be `mindspore.bool` .
         - The shape of returned tensor is :math:`input\_params.shape[:axis] + input\_indices.shape[batch\_dims:] + input\_params.shape[axis + 1:]` .
 
     Args:
@@ -3785,7 +3835,7 @@ def hfft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `hfft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `hfft2` is not supported on Windows platform yet.
 
     Args:
@@ -3846,7 +3896,7 @@ def hfftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `hfftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `hfftn` is not supported on Windows platform yet.
 
     Args:
@@ -3907,7 +3957,7 @@ def hfft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `hfft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `hfft` is not supported on Windows platform yet.
 
     Args:
@@ -4168,7 +4218,7 @@ def ifft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `ifft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ifft2` is not supported on Windows platform yet.
 
     Args:
@@ -4228,7 +4278,7 @@ def ifftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `ifftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ifftn` is not supported on Windows platform yet.
 
     Args:
@@ -4288,7 +4338,7 @@ def ifftshift(input, dim=None):
 
     Note:
         - `ifftshift` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ifftshift` is not supported on Windows platform yet.
 
     Args:
@@ -4324,7 +4374,7 @@ def ifft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `ifft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ifft` is not supported on Windows platform yet.
 
     Args:
@@ -4380,7 +4430,7 @@ def ihfft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `ihfft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ihfft2` is not supported on Windows platform yet.
 
     Args:
@@ -4441,7 +4491,7 @@ def ihfftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `ihfftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ihfftn` is not supported on Windows platform yet.
 
     Args:
@@ -4502,7 +4552,7 @@ def ihfft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `ihfft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `ihfft` is not supported on Windows platform yet.
 
     Args:
@@ -4623,56 +4673,6 @@ def unfold_ext(input, kernel_size, dilation=1, padding=0, stride=1):
     return im2col_ext_op(input, kernel_size, dilation, padding, stride)
 
 
-def index_add_ext(input, dim, index, source, alpha=1):
-    r"""
-    Accumulate the elements of `alpha` times `source` into the `input` by adding to the index in the order given in `index`. For example, if ``dim == 0`` , ``index[i] == j`` , and ``alpha = -1`` , then the `i` th row of `source` is subtracted from the `j` th row of `input` . The `dim` th dimension of `source` must have the same size as the length of `index` , and all other dimensions must match `input`, or an error will be raised. For a 3-D tensor, the output is defined as follows:
-
-    .. math::
-        \begin{array}{ll}
-        input[index[i],\ :,\ :]\ +=\ alpha * source[i,\ :,\ :]  \qquad \#if\ dim == 0 \\
-        input[:,\ \ index[i],\ :]\ +=\ alpha * source[:,\ \ i,\ :]  \qquad \#if\ dim == 1 \\
-        input[:,\ :,\ \ index[i]]\ +=\ alpha * source[:,\ :,\ \ i]  \qquad\#if\ dim == 2 \\
-        \end{array}
-        
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-        
-    Args:
-        input (Tensor): The input Tensor.
-        dim (int): The dimension along which to index.
-        index (Tensor): Add the value of "input Tensor" and `source` along the dimension of the `dim` according to the specified index value, with data type int32. The `index` must be 1D with the same size as the size of `source` in the `dim` dimension. The values of `index` should be in [0, b), where the b is the size of "input Tensor" in the `dim` dimension.
-        source (Tensor): The input tensor with the value to add. Must have same data type as "input Tensor". The shape must be the same as "input Tensor" except the `dim` th dimension.
-        alpha (number, optional): The scalar multiplier for source. Default: ``1``.
-        
-    Returns:
-        Tensor, has the same shape and dtype as `input`.
-
-    Raises:
-        TypeError: If neither `index` nor `source` is a Tensor.
-        ValueError: If the value of `dim` is out of the dimension range of `source` shape.
-        ValueError: If `index` rank is not the same as `source` rank.
-        ValueError: If shape of `index` is not 1D or size of `index` is not equal to dimension of source[dim].
-        ValueError: If the shape of `source` is not the same as that of `input` except the `dim` axis.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
-        >>> index = Tensor(np.array([0, 2]), mindspore.int32)
-        >>> y = Tensor(np.array([[0.5, 1.0], [1.0, 1.5], [2.0, 2.5]]), mindspore.float32)
-        >>> output = ops.auto_generate.index_add_ext(x, 1, index, y, alpha=1)
-        >>> print(output)
-        [[ 1.5  2.   4. ]
-         [ 5.   5.   7.5]
-         [ 9.   8.  11.5]]
-    """
-    return index_add_ext_op(input, dim, index, source, alpha)
-
-
 def index_fill_scalar(input, dim, index, value):
     r"""
     
@@ -4728,7 +4728,7 @@ def index(input, indices):
         [2 6 5]
         >>> input2 = Tensor(np.arange(4 * 3 * 3).reshape(4, 3, 3), mindspore.int32)
         >>> indices3 = Tensor(np.array([1, 0]), mindspore.int32)
-        >>> indices4 = Tensor(np.array([1, 1, 0]), mindspore.bool_)
+        >>> indices4 = Tensor(np.array([1, 1, 0]), mindspore.bool)
         >>> output2 = ops.auto_generate.index(input2, [indices3, indices4])
         >>> print(output2)
         [[ 9 10 11]
@@ -4783,6 +4783,13 @@ def index_select_ext(input, dim, index):
     return index_select_op(input, dim, index)
 
 
+def inner_moe_token_unpermute(permuted_tokens, sorted_indices, probs=None, padded_mode=False, restore_shape=None):
+    r"""
+    
+    """
+    return inner_moe_token_unpermute_op(permuted_tokens, sorted_indices, probs, padded_mode, restore_shape)
+
+
 def inplace_adds_ext(input, other, alpha=1):
     r"""
     
@@ -4797,6 +4804,20 @@ def inplace_add_ext(input, other, alpha=1):
     return inplace_add_ext_op(input, other, alpha)
 
 
+def inplace_bernoulli_scalar(input, p, seed, offset):
+    r"""
+    
+    """
+    return inplace_bernoulli_scalar_op(input, p, seed, offset)
+
+
+def inplace_bernoulli_tensor(input, p, seed, offset):
+    r"""
+    
+    """
+    return inplace_bernoulli_tensor_op(input, p, seed, offset)
+
+
 def inplace_clamp_scalar(input, min=None, max=None):
     r"""
     
@@ -4811,11 +4832,11 @@ def inplace_clamp_tensor(input, min=None, max=None):
     return inplace_clamp_tensor_op(input, min, max)
 
 
-def inplace_copy(input, src):
+def inplace_copy(input, src, non_blocking=False):
     r"""
     
     """
-    return inplace_copy_op(input, src)
+    return inplace_copy_op(input, src, non_blocking)
 
 
 def divmod_scalar_(input, other, rounding_mode=None):
@@ -5090,6 +5111,51 @@ def masked_fill_tensor_(input, mask, value):
     return inplace_masked_fill_tensor_op(input, mask, value)
 
 
+def matmul_add_(x, weight, C):
+    r"""
+    Fusion Operator of Transpose, Matmul, and InplaceAdd.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - This API is only supported in Atlas A2 training series for now.
+        - This API is only supported on GRAPH mode.
+
+    Args:
+        x (Tensor): Matrix A in matrix multiplication, with shape :math:`(k, m)` or :math:`(batch, k, m)`,
+            whose type should be float16 or bfloat16.
+        weight (Tensor): Matrix B in matrix multiplication, with shape :math:`(k, n)` or :math:`(batch, k, n)`,
+            whose type should be float16 or bfloat16.
+        C (Tensor): A Tensor acting as both input and output, with type of float32.
+            It's shape should be :math:`(m, n)` or :math:`(batch, m, n)`.
+
+    Returns:
+        Tensor, has the same shape and data type as `C`.
+
+    Raises:
+        TypeError: If the dtype of `weight` is not the same as `x`.
+        ValueError: If the ranks of `x` , `weight` and `C` are not the same.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, nn, context
+        >>> context.set_context(mode=context.GRAPH_MODE, jit_config={"jit_level": "O0"})
+        >>> class Net(nn.Cell):
+        ...     def construct(self, x, weight, C):
+        ...        return ops.auto_generate.inplace_matmul_add_op(x, weight, C)
+        >>> x = Tensor(np.random.randn(10, 20), mindspore.float16)
+        >>> weight = Tensor(np.random.randn(10, 8), mindspore.float16)
+        >>> C = Tensor(np.random.randn(20, 8), mindspore.float32)
+        >>> output = Net()(x, weight, C)
+        >>> print(output.shape)
+        (20, 8)
+    """
+    return inplace_matmul_add_op(x, weight, C)
+
+
 def inplace_muls(input, other):
     r"""
     
@@ -5118,6 +5184,52 @@ def inplace_scatter_add(input, dim, index, src):
     return inplace_scatter_add_op(input, dim, index, src)
 
 
+def inplace_silu(input):
+    r"""
+    Computes Sigmoid Linear Unit of input element-wise. The SiLU function is defined as:
+
+    .. math::
+
+        \text{SiLU}(x) = x * \sigma(x),
+
+    where :math:`x` is an element of the input, :math:`\sigma(x)` is Sigmoid function.
+
+    .. math::
+
+        \text{sigma}(x_i) = \frac{1}{1 + \exp(-x_i)},
+
+    SiLU Function Graph:
+
+    .. image:: ../images/SiLU.png
+        :align: center
+
+    Args:
+        input (Tensor): `input` is :math:`x` in the preceding formula. Input with the data type
+            float16 or float32.
+        inplace (bool, optional): If it is ``True``, enable the in place update function.
+            Default value: ``False``.
+
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is neither float16 nor float32.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> output = mint.nn.functional.silu(input, inplace=True)
+        >>> print(output)
+        [-0.269  1.762  -0.1423  1.762  -0.269]
+    """
+    return inplace_silu_op(input)
+
+
 def inplace_stop_gradient(input):
     r"""
     
@@ -5159,9 +5271,6 @@ def inplace_threshold(input, threshold, value):
         \text{value}, &\text{ otherwise }
         \end{cases}
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input Tensor.
         threshold (Union[int, float]): The value of the threshold.
@@ -5202,7 +5311,7 @@ def irfft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `irfft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `irfft2` is not supported on Windows platform yet.
 
     Args:
@@ -5260,7 +5369,7 @@ def irfftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `irfftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `irfftn` is not supported on Windows platform yet.
 
     Args:
@@ -5319,7 +5428,7 @@ def irfft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `irfft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `irfft` is not supported on Windows platform yet.
 
     Args:
@@ -5502,6 +5611,13 @@ def kthvalue(input, k, dim=-1, keepdim=False):
     return kthvalue_op(input, k, dim, keepdim)
 
 
+def kv_scale_cache(key_scale, value_scale, key_value_scale_cache, batch_valid_length, cache_mode):
+    r"""
+    
+    """
+    return kv_scale_cache_op(key_scale, value_scale, key_value_scale_cache, batch_valid_length, cache_mode)
+
+
 def l1_loss_ext(input, target, reduction='mean'):
     r"""
     Calculate the mean absolute error between the `input` value and the `target` value.
@@ -6157,7 +6273,7 @@ def masked_fill(input_x, mask, value):
     Examples:
         >>> import mindspore
         >>> input_x = mindspore.tensor([1., 2., 3., 4.], mindspore.float32)
-        >>> mask = mindspore.tensor([True, True, False, True], mindspore.bool_)
+        >>> mask = mindspore.tensor([True, True, False, True], mindspore.bool)
         >>> output = mindspore.ops.masked_fill(input_x, mask, 0.5)
         >>> print(output)
         [0.5 0.5 3.  0.5]
@@ -6165,6 +6281,13 @@ def masked_fill(input_x, mask, value):
     return masked_fill_op(input_x, mask, value)
 
 
+def masked_scatter(input, mask, source):
+    r"""
+    
+    """
+    return masked_scatter_op(input, mask, source)
+
+
 def masked_select(input, mask):
     r"""
     Return a new 1-D tensor which indexes the `input` tensor according to the boolean `mask`.
@@ -6184,7 +6307,7 @@ def masked_select(input, mask):
     Examples:
         >>> import mindspore
         >>> x = mindspore.tensor([1, 2, 3, 4], mindspore.int64)
-        >>> mask = mindspore.tensor([1, 0, 1, 0], mindspore.bool_)
+        >>> mask = mindspore.tensor([1, 0, 1, 0], mindspore.bool)
         >>> output = mindspore.ops.masked_select(x, mask)
         >>> print(output)
         [1 3]
@@ -6561,6 +6684,20 @@ def mish_ext(input):
     return mish_ext_op(input)
 
 
+def mla(query, q_rope, kv_cache, k_rope, block_tables, attn_mask=None, deq_scale_qk=None, deq_scale_pv=None, q_seq_lens=None, context_lens=None, head_num=32, scale_value=0.0, kv_head_num=1, mask_mode='MASK_NONE', is_ring=0):
+    r"""
+    
+    """
+    return mla_op(query, q_rope, kv_cache, k_rope, block_tables, attn_mask, deq_scale_qk, deq_scale_pv, q_seq_lens, context_lens, head_num, scale_value, kv_head_num, mask_mode, is_ring)
+
+
+def mla_preprocess(input1, gamma1, beta1, quant_scale1, quant_offset1, wdqkv, bias1, gamma2, beta2, quant_scale2, quant_offset2, gamma3, sin1, cos1, sin2, cos2, key_cache, slot_mapping, wuq, bias2, slot_wuk, de_scale1, de_scale2, ctkv_scale, qnope_scale, krope_cache, param_cache_mode=0):
+    r"""
+    
+    """
+    return mla_preprocess_op(input1, gamma1, beta1, quant_scale1, quant_offset1, wdqkv, bias1, gamma2, beta2, quant_scale2, quant_offset2, gamma3, sin1, cos1, sin2, cos2, key_cache, slot_mapping, wuq, bias2, slot_wuk, de_scale1, de_scale2, ctkv_scale, qnope_scale, krope_cache, param_cache_mode)
+
+
 def mm_ext(input, mat2):
     r"""
     Returns the matrix product of two arrays.
@@ -6605,6 +6742,254 @@ def mm_ext(input, mat2):
     return mm_ext_op(input, mat2)
 
 
+def moe_distribute_combine(expand_x, expert_ids, expand_idx, ep_send_counts, expert_scales, ep_world_size, ep_rank_id, moe_expert_num, tp_send_counts=None, x_active_mask=None, activate_scale=None, weight_scale=None, group_list=None, expand_scales=None, group_ep=None, group_tp=None, tp_world_size=0, tp_rank_id=0, expert_shard_type=0, shared_expert_num=0, shared_export_rank_num=0, global_bs=0, out_dtype=0, common_quant_mode=0, group_list_type=0):
+    r"""
+    Parallel communication for Mixture of Experts (MoE). When Tensor Parallelism (TP) communication exists,
+    it first ReduceScatter performs communication followed by Expert Parallelism (EP) AllToAllV communication.
+    Otherwise, only EP AllToAllV communication is performed. Finally multiply the received data by weight and
+    add them up.
+
+    Notes:
+        This function must be used in conjunction with function `moe_distribute_dispatch`.
+        - A: Maximum tokens to dispatch per rank:
+            - For shared experts: A = BS * ep_world_size * shared_expert_num / shared_expert_rank_num
+            - For MoE experts:
+                - When global_bs = 0: A >= BS * ep_world_size * min(local_expert_num, K)
+                - When global_bs != 0: A >= global_bs * min(local_expert_num, K)
+        - H (hidden size): Dimension of each token's hidden state
+            - Ascend 910B: 0 < H <= 7168, must be multiple of 32
+            - Ascend 910_93: H = 7168
+        - BS (batch sequence size): Number of tokens processed per rank
+            - Ascend 910B: 0 < BS <= 256
+            - Ascend 910_93: 0 < BS <= 512
+        - K: Number of experts selected per token (0 < K <= 8 and K <= moe_expert_num)
+        - server_num: Number of server nodes (supports 2, 4, 8)
+        - local_expert_num: Number of experts per rank:
+            - Shared expert ranks: local_expert_num = 1
+            - MoE expert ranks: local_expert_num = moe_expert_num / (ep_world_size - shared_expert_rank_num)
+            (TP communication not supported when localExpertNum > 1)
+
+    Inputs:
+        - **expand_x** (Tensor) - Expanded token features. 2D tensor [A, H] with dtype matching input.
+            Supported dtypes: float16, bfloat16, int8. Format: ND, non-contiguous allowed.
+        - **expert_ids** (Tensor) - Top-K expert indices for each token. 2D int32 tensor with shape [BS, K].
+            Format: ND, non-contiguous allowed.
+        - **expert_idx** (Tensor) - Token counts per expert, it's the output of dispatch operation. 
+            1D int32 tensor [BS*K]. Format: ND, non-contiguous allowed.
+        - **ep_send_counts** (Tensor) - Tokens that each EP rank needs to send, it's the output of dispatch operation.
+            - Ascend 910B: 1D int32 tensor [moe_expert_num + 2 * global_bs * K * server_num]
+            - Ascend 910_93: 1D int32 tensor [ep_world_size * max(tp_world_size,1) * local_expert_num]
+            Format: ND, non-contiguous allowed.
+        - **expert_scales** (Tensor) - Top-K expert weights per token.
+        - **ep_world_size** (int) - EP domain size.
+            - Ascend 910B: Supports 16, 32, 64.
+            - Ascend 910_93: Supports 8, 16, 32, 64, 128, 144, 256, 288.
+        - **ep_rank_id** (int) - Local rank ID in EP domain [0, ep_world_size), must be unique per domain.
+        - **moe_expert_num** (int) - Number of MoE experts (0 < moe_expert_num <= 256), 
+            must satisfy moe_expert_num % (ep_world_size-shared_expert_rank_num) = 0.
+        - **tp_send_counts** (Tensor) - Tokens that each TP rank needs to send (when TP exists). It's the output of dispatch operation. Default: ``None``.
+            - Ascend 910B: Not supported.
+            - Ascend 910_93: 1D int32 tensor [tp_world_size] when TP exists. Format: ND, non-contiguous allowed.
+        - **x_active_mask** (Tensor) - Reserved parameter. Default: ``None``.
+        - **activate_scale** (Tensor) - Reserved parameter. Default: ``None``.
+        - **weight_scale** (Tensor) - Reserved parameter. Default: ``None``.
+        - **group_list** (Tensor) - Reserved parameter. Default: ``None``.
+        - **expand_scales** (Tensor) - Output of dispatch operation. Default: ``None``.
+            - Ascend 910B: 1D float32 tensor [A]. Format: ND, non-contiguous allowed.
+            - Ascend 910_93: Unsupported.
+        - **group_ep** (str) - EP communication domain name (string length 1-127), must differ from group_tp. Default: ``None``.
+        - **group_tp** (str) - TP communication domain name. Default: ``None``.
+            - Ascend 910B: Unsupported (pass empty string).
+            - Ascend 910_93: When TP communication exists, string length 1-127, must differ from group_ep.
+        - **tp_world_size** (int) - TP domain size. Default: ``0``.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: 0/1 means no TP communication; only 2 supported when TP exists.
+        - **tp_rank_id** (int) - Local rank ID in TP domain. Default: ``0``.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: [0,1], unique per domain; pass 0 when no TP communication.
+        - **expert_shard_type** (int) - Shared expert distribution type. Default: ``0``.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: Currently only 0 (shared experts precede MoE experts).
+        - **shared_expert_num** (int) - Number of shared experts. Default: ``0``.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: Currently 0 (none) or 1 (one shared expert).
+        - **shared_expert_rank_num** (int) - Number of ranks hosting shared experts. Default: ``0``.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: [0, ep_world_size-1), must satisfy ep_world_size % shared_expert_rank_num = 0 when non-zero.
+        - **global_bs** (int) - Global batch size across EP domain. Default: ``0``.
+            - Ascend 910B: 256*ep_world_size when BS varies per rank; 0 or BS*ep_world_size when uniform.
+            - Ascend 910_93: 0 or BS*ep_world_size.
+        - **out_dtype** (int) - Specify the type of output x. Reserved parameter (pass 0 in current version). Default: ``0``.
+        - **common_quant_mode** (int) - Communication quantification type. Reserved parameter (pass 0 in current version). Default: ``0``.
+        - **group_list_type** (int) - The format of group_list. Reserved parameter (pass 0 in current version). Default: ``0``.
+
+    Outputs:
+        - **x** (Tensor) - Processed tokens. 2D tensor [BS, H] with dtype matching input `expand_x`.
+
+    Raises:
+        TypeError: If input dtypes don't match specifications.
+        ValueError: If input values violate constraints (e.g., invalid expert indices).
+        RuntimeError: If communication domain configuration is invalid.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+    >>> # EP-only communication example (Ascend 910B)
+    >>> import mindspore as ms
+    >>> from mindspore import Tensor
+    >>> from mindspore import ops
+    >>> from mindspore.communication import init, get_rank, GlobalComm
+    >>> from mindspore.ops.auto_generate import moe_distribute_dispatch, moe_distribute_combine
+    >>> import numpy as np
+    >>> bs = 8
+    >>> h = 7168
+    >>> k = 8
+    >>> ep_world_size = 16
+    >>> moe_expert_num = 16
+    >>> global_bs = bs * ep_world_size
+    >>> x = Tensor(np.random.randn(bs, h), ms.float16)
+    >>> expert_ids = Tensor(np.random.randint(0, moe_expert_num, (bs, k)), ms.int32)
+    >>> expert_scales = Tensor(np.random.randn(bs, k), ms.float32)
+    >>> init()
+    >>> rank_id = get_rank()
+    >>> expand_x, _, expand_idx, _, ep_recv_count, _, expand_scale = moe_distribute_dispatch(
+    ...     x, expert_ids, expert_scales, ep_world_size, rank_id, moe_expert_num,
+    ...     group_ep=GlobalComm.WORLD_COMM_GROUP)
+    >>> out_x = moe_distribute_combine(
+    ...     expand_x, expert_ids, expand_idx, ep_recv_count, expert_scales, ep_world_size, rank_id,
+    ...     moe_expert_num, group_ep=GlobalComm.WORLD_COMM_GROUP)
+    >>> print(out_x.shape)
+    (8, 7168)
+    """
+    return moe_distribute_combine_op(expand_x, expert_ids, expand_idx, ep_send_counts, expert_scales, ep_world_size, ep_rank_id, moe_expert_num, tp_send_counts, x_active_mask, activate_scale, weight_scale, group_list, expand_scales, group_ep, group_tp, tp_world_size, tp_rank_id, expert_shard_type, shared_expert_num, shared_export_rank_num, global_bs, out_dtype, common_quant_mode, group_list_type)
+
+
+def moe_distribute_dispatch(x, expert_ids, ep_world_size, ep_rank_id, moe_expert_num, expert_scales=None, scales=None, x_active_mask=None, group_ep=None, group_tp=None, tp_world_size=0, tp_rank_id=0, expert_shard_type=0, shared_expert_num=0, shared_expert_rank_num=0, quant_mode=0, global_bs=0, expert_token_nums_type=0):
+    r"""
+    Performs token data quantization (optional) and parallel communication for Mixture of Experts (MoE).
+    When Tensor Parallelism (TP) communication exists, it first performs Expert Parallelism (EP) AllToAllV
+    communication followed by TP AllGatherV communication. Otherwise, only EP AllToAllV communication is performed.
+
+    Notes:
+        - A: Maximum tokens to dispatch per rank:
+            - For shared experts: A = BS * ep_world_size * shared_expert_num / shared_expert_rank_num
+            - For MoE experts:
+                - When global_bs = 0: A >= BS * ep_world_size * min(local_expert_num, K)
+                - When global_bs != 0: A >= global_bs * min(local_expert_num, K)
+        - H (hidden size): Dimension of each token's hidden state
+            - Ascend 910B: 0 < H <= 7168, must be multiple of 32
+            - Ascend 910_93: H = 7168
+        - BS (batch sequence size): Number of tokens processed per rank
+            - Ascend 910B: 0 < BS <= 256
+            - Ascend 910_93: 0 < BS <= 512
+        - K: Number of experts selected per token (0 < K <= 8 and K <= moe_expert_num)
+        - server_num: Number of server nodes (supports 2, 4, 8)
+        - local_expert_num: Number of experts per rank:
+            - Shared expert ranks: local_expert_num = 1
+            - MoE expert ranks: local_expert_num = moe_expert_num / (ep_world_size - shared_expert_rank_num)
+            (TP communication not supported when localExpertNum > 1)
+
+    Inputs:
+        - **x** (Tensor) - Input token data to be sent. 2D tensor with shape [BS, H].
+            Supported dtypes: float16, bfloat16. Format: ND, non-contiguous allowed.
+        - **expert_ids** (Tensor) - Top-K expert indices for each token. 2D int32 tensor with shape [BS, K].
+            Format: ND, non-contiguous allowed.
+        - **ep_world_size** (int64) - EP domain size.
+            - Ascend 910B: Supports 16, 32, 64.
+            - Ascend 910_93: Supports 8, 16, 32, 64, 128, 144, 256, 288.
+        - **ep_rank_id** (int64) - Local rank ID in EP domain [0, ep_world_size), must be unique per domain.
+        - **moe_expert_num** (int64) - Number of MoE experts (0 < moe_expert_num <= 256),
+            must satisfy moe_expert_num % (ep_world_size-shared_expert_rank_num) = 0.
+        - **expert_scales** (Tensor) - Top-K expert weights per token.
+            - Ascend 910B: 2D float32 tensor [BS, K], ND format, non-contiguous allowed.
+            - Ascend 910_93: Unsupported (pass nullptr).
+        - **scales** (Tensor) - Expert weights. 2D float32 tensor with shape [shared_expert_num + moe_expert_num, H].
+            Pass nullptr for non-quantized scenarios. Format: ND, non-contiguous allowed.
+            Note: On Ascend 910B, must be nullptr when HCCL_INTRA_PCIE_ENABLE=1 and HCCL_INTRA_ROCE_ENABLE=0.
+        - **x_active_mask** (Tensor) - Reserved parameter (pass nullptr in current version).
+        - **group_ep** (str) - EP communication domain name (string length 1-127), must differ from group_tp.
+        - **group_tp** (str) - TP communication domain name.
+            - Ascend 910B: Unsupported (pass empty string).
+            - Ascend 910_93: When TP communication exists, string length 1-127, must differ from group_ep.
+        - **tp_world_size** (int64) - TP domain size.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: 0/1 means no TP communication; only 2 supported when TP exists.
+        - **tp_rank_id** (int64) - Local rank ID in TP domain.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: [0,1], unique per domain; pass 0 when no TP communication.
+        - **expert_shard_type** (int64) - Shared expert distribution type.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: Currently only 0 (shared experts precede MoE experts).
+        - **shared_expert_num** (int64) - Number of shared experts.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: Currently 0 (none) or 1 (one shared expert).
+        - **shared_expert_rank_num** (int64) - Number of ranks hosting shared experts.
+            - Ascend 910B: Unsupported (pass 0).
+            - Ascend 910_93: [0, ep_world_size-1), must satisfy ep_world_size % shared_expert_rank_num = 0 when non-zero.
+        - **quant_mode** (int64) - Quantization mode: 0 (none), 2 (dynamic quantization).
+        - **global_bs** (int64) - Global batch size across EP domain.
+            - Ascend 910B: 256*ep_world_size when BS varies per rank; 0 or BS*ep_world_size when uniform.
+            - Ascend 910_93: 0 or BS*ep_world_size.
+        - **expert_token_nums_type** (int64) - Semantic meaning of expert_token_nums output:
+            0 (prefix sums), 1 (raw counts).
+
+    Outputs:
+        - **expand_x** (Tensor) - Expanded token features. 2D tensor [A, H] with dtype matching input.
+            Supported dtypes: float16, bfloat16, int8. Format: ND, non-contiguous allowed.
+        - **dynamic_scales** (Tensor) - Dynamic quantization scales (when quant_mode=2).
+            1D float32 tensor [A]. Format: ND, non-contiguous allowed.
+        - **expand_idx** (Tensor) - Token counts per expert for combine operation.
+            1D int32 tensor [BS*K]. Format: ND, non-contiguous allowed.
+        - **expert_token_nums** (Tensor) - Tokens received per expert.
+            1D int64 tensor [local_expert_num]. Format: ND, non-contiguous allowed.
+        - **ep_recv_counts** (Tensor) - Tokens received from each EP rank.
+            - Ascend 910B: 1D int32 tensor [moe_expert_num + 2 * global_bs * K * server_num]
+            - Ascend 910_93: 1D int32 tensor [ep_world_size * max(tp_world_size,1) * local_expert_num]
+            Format: ND, non-contiguous allowed.
+        - **tp_recv_counts** (Tensor) - Tokens received from each TP rank (when TP exists).
+            - Ascend 910B: Not supported.
+            - Ascend 910_93: 1D int32 tensor [tp_world_size] when TP exists. Format: ND, non-contiguous allowed.
+        - **expand_scales** (Tensor) - Output token weights for combine operation.
+            - Ascend 910B: 1D float32 tensor [A]. Format: ND, non-contiguous allowed.
+            - Ascend 910_93: Unsupported.
+
+    Raises:
+        TypeError: If input dtypes don't match specifications.
+        ValueError: If input values violate constraints (e.g., invalid expert indices).
+        RuntimeError: If communication domain configuration is invalid.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+    >>> # EP-only communication example (Ascend 910B)
+    >>> import mindspore as ms
+    >>> from mindspore import Tensor
+    >>> from mindspore import ops
+    >>> from mindspore.communication import init, get_rank, GlobalComm
+    >>> from mindspore.ops.auto_generate import moe_distribute_dispatch
+    >>> import numpy as np
+    >>> bs = 8
+    >>> h = 7168
+    >>> k = 8
+    >>> ep_world_size = 16
+    >>> moe_expert_num = 16
+    >>> global_bs = bs * ep_world_size
+    >>> x = Tensor(np.random.randn(bs, h), ms.float16)
+    >>> expert_ids = Tensor(np.random.randint(0, moe_expert_num, (bs, k)), ms.int32)
+    >>> expert_scales = Tensor(np.random.randn(bs, k), ms.float32)
+    >>> init()
+    >>> rank_id = get_rank()
+    >>> out = moe_distribute_dispatch(
+    ...     x, expert_ids, ep_world_size, rank_id, moe_expert_num, expert_scales=expert_scales,
+    ...     group_ep=GlobalComm.WORLD_COMM_GROUP)
+    >>> print(out[0].shape)  # expand_x
+    (128, 7168)
+    """
+    return moe_distribute_dispatch_op(x, expert_ids, ep_world_size, ep_rank_id, moe_expert_num, expert_scales, scales, x_active_mask, group_ep, group_tp, tp_world_size, tp_rank_id, expert_shard_type, shared_expert_num, shared_expert_rank_num, quant_mode, global_bs, expert_token_nums_type)
+
+
 def moe_token_permute_grad(permuted_tokens_grad, sorted_indices, num_topk=1, padded_mode=False):
     r"""
     
@@ -6618,11 +7003,10 @@ def moe_token_permute(tokens, indices, num_out_tokens=None, padded_mode=False):
 
     .. warning::
         - It is only supported on Atlas A2 Training Series Products.
-        - The input `tokens` only supports the bfloat16 data type in the current version.
         - When `indices` is 2-D, the size of the second dim must be less than or equal to 512.
 
     Args:
-        tokens (Tensor): The input token tensor to be permuted. The dtype is bfloat16.
+        tokens (Tensor): The input token tensor to be permuted. The dtype is bfloat16, float16 or float32.
             The shape is :math:`(num\_tokens, hidden\_size)` , where `num_tokens` and `hidden_size` are positive integers.
         indices (Tensor): The tensor specifies indices used to permute the tokens. The dtype is int32 or int64.
             The shape is :math:`(num\_tokens, topk)` or :math:`(num\_tokens,)`, where `num_tokens` and `topk` are positive integers.
@@ -6638,7 +7022,6 @@ def moe_token_permute(tokens, indices, num_out_tokens=None, padded_mode=False):
 
     Raises:
         TypeError: If `tokens` or `indices` is not a Tensor.
-        TypeError: If dtype of `tokens` is not bfloat16.
         TypeError: If dtype of `indices` is not int32 or int64.
         TypeError: If specified `num_out_tokens` is not an integer.
         TypeError: If specified `padded_mode` is not a bool.
@@ -6680,60 +7063,6 @@ def moe_token_unpermute_grad(permuted_tokens, unpermuted_tokens_grad, sorted_ind
     return moe_token_unpermute_grad_op(permuted_tokens, unpermuted_tokens_grad, sorted_indices, probs, padded_mode, restore_shape)
 
 
-def moe_token_unpermute(permuted_tokens, sorted_indices, probs=None, padded_mode=False, restore_shape=None):
-    r"""
-    Unpermute a tensor of permuted tokens based on sorted indices, and optionally merge the tokens with their corresponding probabilities.
-
-    .. warning::
-        - It is only supported on Atlas A2 Training Series Products.
-        - The inputs `permuted_tokens` and `probs` only support the bfloat16 data type in the current version.
-        - `sorted_indices` must not have duplicate values, otherwise the result is undefined.
-
-    Args:
-        permuted_tokens (Tensor): The tensor of permuted tokens to be unpermuted.
-            The shape is :math:`[num\_tokens * topk, hidden\_size]` , where `num_tokens`, `topk` and `hidden_size` are positive integers.
-        sorted_indices (Tensor): The tensor of sorted indices used to unpermute the tokens.
-            The shape is :math:`[num\_tokens * topk,]`, where `num_tokens` and `topk` are positive integers.
-            It only supports the int32 data type.
-        probs (Tensor, optional): The tensor of probabilities corresponding to the permuted tokens.
-            If provided, the unpermuted tokens will be merged with their respective probabilities.
-            The shape is :math:`[num\_tokens, topk]`, where `num_tokens` and `topk` are positive integers. Default: ``None`` .
-        padded_mode (bool, optional): If ``True``, indicating the indices are padded to denote selected tokens per expert. Default: ``False`` .
-        restore_shape (Union[tuple[int], list[int]], optional): The input shape before permutation, only used in padding mode. Default: ``None`` .
-
-    Returns:
-        Tensor, with the same dtype as `permuted_tokens`. If `padded_mode` is ``False``, the shape will be [`num_tokens`, `hidden_size`].
-        If `padded_mode` is ``True``, the shape will be specified by `restore_shape`.
-
-    Raises:
-        TypeError: If `permuted_tokens` is not a Tensor.
-        ValueError: Only supported when `padded_mode` is ``False``.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> permuted_token = Tensor([
-        ...                          [1, 1, 1],
-        ...                          [0, 0, 0],
-        ...                          [0, 0, 0],
-        ...                          [3, 3, 3],
-        ...                          [2, 2, 2],
-        ...                          [1, 1, 1],
-        ...                          [2, 2, 2],
-        ...                          [3, 3, 3]], dtype=mindspore.bfloat16)
-        >>> sorted_indices = Tensor([0, 6, 7, 5, 3, 1, 2, 4], dtype=mindspore.int32)
-        >>> out = ops.moe_token_unpermute(permuted_token, sorted_indices)
-        >>> out.shape
-        (8, 3)
-        
-        
-    """
-    return moe_token_unpermute_op(permuted_tokens, sorted_indices, probs, padded_mode, restore_shape)
-
-
 def mse_loss_ext(input, target, reduction='mean'):
     r"""
     Calculates the mean squared error between the predicted value and the label value.
@@ -6797,7 +7126,7 @@ def mul(input, other):
         - When the two inputs have different shapes,
           they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
         - Support implicit type conversion and type promotion.
 
     Args:
@@ -7193,8 +7522,10 @@ def prelu(input, weight):
         :align: center
 
     .. note::
-        Channel dim is the 2nd dim of input. When input has dims < 2, then there is
-        no channel dim and the number of channels = 1.
+        - Channel dim is the 2nd dim of input. When input has dims < 2, then there is
+          no channel dim and the number of channels = 1.
+        - In GE mode, the rank of the input tensor must be greater than 1;
+          otherwise, an error will be triggered.
 
     Args:
         input (Tensor): The input Tensor of the activation function.
@@ -7307,65 +7638,6 @@ def prod_ext(input, dim=None, keepdim=False, dtype=None):
     return prod_ext_op(input, dim, keepdim, dtype)
 
 
-def prompt_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len, align_mode='LEFT'):
-    r"""
-    The PromptKVCache is used for prefill the KVCache of transformer network.
-
-    Args:
-        cache (Tensor): The cahe tensor with data type of int8, uint8, int16, uint16, float16, float32 and int32.
-          When format is BHSD, cache tensor of shape
-          :math:`(cache\_batch\_size, num\_head, max\_seq\_length, size\_pre\_head)`.
-          When format is BSD, cache tensor of shape
-          :math:`(cache\_batch\_size, max\_seq\_length, hidden\_size)`.
-        update (Tensor]): The tensor which is used to update the cache tensor. Same data type as cache tensor.
-          When format is BHSD, cache tensor of shape
-          :math:`(update\_batch\_size, num\_head, max\_seq\_length, size\_pre\_head)`.
-          When format is BSD, cache tensor of shape
-          :math:`(update\_batch\_size, max\_seq\_length, hidden\_size)`.
-        valid_seq_len (Tensor): The valid_seq_len tensor with data type of int64.
-          Valid_seq_len tensor of shape :math:`(update\_batch\_size)`.
-        batch_index (Tensor): The batch_index tensor with data type of int64.
-          Batch_index tensor of shape :math:`(update\_batch\_size)`. Indicate that which batch of cache tensor is going to be update.
-        seq_len_axis (Tensor): The seq_len_axis indicate which axis is seq_eln, set to '1' or '2'. Not able for now.
-        new_max_seq_len (Tensor): The new_max_seq_len tensor with data type of int64.
-          New_max_seq_len tensor of shape :math:`(1)`.
-          Indicate that user want to change the shape of cache tensor from
-          :math:`(batch\_size, num_head, max\_seq\_length, hidden\_size)` to
-          :math:`(batch\_size * max\_seq\_length / new\_max\_seq\_length, num_head, new\_max\_seq\_length, hidden\_size)`
-          to update the cache tensor. This will not real change the shape of `cache` tensor. Not able for now.
-        cur_max_seq_len (Tensor): The new_max_seq_len tensor with data type of int64.
-          Cur_max_seq_len tensor of shape :math:`(1)`. Keep the current seq_len of cache tensor. Not abel for now.
-        align_mode (str): indicate which axis is seq_len. Default: left.
-
-
-    Outputs:
-        With same data type and same shape as `cache` tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore import Tensor
-        >>> from mindspore.ops.operations import _inner_ops
-        >>> b = 4
-        >>> h = 40
-        >>> max_s = 1024
-        >>> s = 256
-        >>> d = 128
-        >>> cache = Tensor(np.random.randn(b, h, max_s, d).astype(np.float16))
-        >>> update = Tensor(np.random.randn(b, h, s, d).astype(np.float16))
-        >>> valid_seq_len = Tensor(np.random.randint(-1, s, size=ub).astype(np.int64))
-        >>> batch_index = Tensor(np.random.choice(np.arange(-1, b), size=ub, replace=False).astype(np.int64))
-        >>> new_max_seq_len = Tensor(np.random.randn(1).astype(np.int64))
-        >>> cur_max_seq_len = Tensor(np.random.randn(1).astype(np.int64))
-        >>> prompt_kv_cache = _inner_ops.PromptKVCache(0)
-        >>> output = prompt_kv_cache(cache, update, valid_seq_len, batch_index, Tensor(2), new_max_seq_len, cur_max_seq_len)
-        >>> print(cache)
-    """
-    prompt_k_v_cache_op = _get_cache_prim(PromptKVCache)(align_mode)
-    return prompt_k_v_cache_op(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len)
-
-
 def randperm(n, seed=0, offset=0, dtype=mstype.int64):
     r"""
     Generates random permutation of integers from 0 to n-1.
@@ -7701,7 +7973,7 @@ def rfft2(input, s=None, dim=(-2, -1), norm=None):
 
     Note:
         - `rfft2` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `rfft2` is not supported on Windows platform yet.
 
     Args:
@@ -7762,7 +8034,7 @@ def rfftfreq(n, d=1.0, dtype=None):
 
     Note:
         - `rfftfreq` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `rfftfreq` is not supported on Windows platform yet.
 
     Args:
@@ -7795,7 +8067,7 @@ def rfftn(input, s=None, dim=None, norm=None):
 
     Note:
         - `rfftn` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `rfftn` is not supported on Windows platform yet.
 
     Args:
@@ -7855,7 +8127,7 @@ def rfft(input, n=None, dim=-1, norm=None):
 
     Note:
         - `rfft` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `rfft` is not supported on Windows platform yet.
 
     Args:
@@ -7898,6 +8170,78 @@ def rfft(input, n=None, dim=-1, norm=None):
     return rfft_op(input, n, dim, norm)
 
 
+def ring_attention_update(prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum, actual_seq_qlen=None, layout='SBH'):
+    r"""
+    The RingAttentionUpdate operator updates the output of two FlashAttention operations based on their respective softmax max and softmax sum values.
+
+    - S: Sequence length
+    - B: Batch dimension
+    - H: Hidden layer size, equals to N * D
+    - T: time, equals to B*S
+    - N: Number of attention heads
+    - D: Head dimension
+
+    .. warning::
+        - It is only supported on Atlas A2 Training Series Products.
+        - This is an experimental API that is subject to change or deletion.
+        - When `layout` is ``"TND"``, the last dimension of `prev_attn_out` must be a multiple of 64.
+        - When `layout` is ``"TND"``, `actual_seq_qlen` is mandatory.
+        - When `layout` is ``"TND"``, N x D must satisfy the constraint:
+          (AlignUp(NxD, 64)x(DataSizex6+8))+(AlignUp(Nx8, 64)x56) <= 192x1024.
+          DataSize is 4 bytes when `prev_attn_out` dtype is float32, 2 bytes when dtype is float16 / bfloat16.
+        - When `layout` is ``"TND"``, if `actual_seq_qlen` is not a non-decreasing sequence from 0 to T, the result is undefined.
+
+    Args:
+        prev_attn_out (Tensor): Output of the first FlashAttention operation. The dtype is float16, float32, bfloat16.
+            The shape is :math:`(S, B, H)` or :math:`(T, N, D)`.
+        prev_softmax_max (Tensor): The max values from the first FlashAttention softmax computation. The dtype float32.
+            The shape is :math:`(B, N, S, 8)` or :math:`(T, N, 8)`. The last dimension contains 8 identical values, which must be positive.
+        prev_softmax_sum (Tensor): The sum values from the first FlashAttention softmax computation.
+            It has the same shape and dtype as `prev_softmax_max`.
+        cur_attn_out (Tensor): Output of the second FlashAttention operation. It has the same shape and dtype as `prev_attn_out`.
+        cur_softmax_max (Tensor): The max values from the second FlashAttention softmax computation. It has the same shape and dtype as `prev_softmax_max`.
+        cur_softmax_sum (Tensor):The sum values from the second FlashAttention softmax computation. It has the same shape and dtype as `prev_softmax_max`.
+        actual_seq_qlen (Tensor, optional): Cumulative sequence length, starting from 0. Required if `layout` is ``"TND"``. Does not take effect if `layout` is ``"SBH"``.
+            The tensor must be 1D and contain non-decreasing integer values starting from 0 to T. Default: ``None``.
+        layout (str, optional): Indicates the input layout, currently support ``"TND"`` and ``"SBH"``. Default: ``"SBH"``.
+
+    Returns:
+        tuple (Tensor), tuple of 3 tensors.
+
+        - **attn_out** (Tensor) - The updated attention out, with the same shape and dtype as `prev_attn_out`.
+        - **softmax_max** (Tensor) - The updated softmax max values, with the same shape and dtype as `prev_softmax_max`.
+        - **softmax_sum** (Tensor) - The updated softmax sum values, with the same shape and dtype as `prev_softmax_max`.
+
+    Raises:
+        RuntimeError: If `layout` is ``"TND"``, and `prev_attn_out`'s last dimension is not aligned to 64.
+        RuntimeError: If `layout` is ``"TND"``, and `actual_seq_qlen` is not provided.
+        RuntimeError: If `layout` is ``"TND"``, and `actual_seq_qlen` is not a non-decreasing sequence from 0 to T.
+        RuntimeError: If `layout` is ``"TND"``, and `prev_attn_out` exceeds the size constraints.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> np.random.seed(123)
+        >>> S, B, H, N= 4, 6, 16, 8
+        >>> prev_attn_out = np.random.uniform(-1.0, 1.0, size=(S, B, H)).astype(np.float32)
+        >>> prev_softmax_max = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
+        >>> prev_softmax_sum = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
+        >>> cur_attn_out = np.random.uniform(-1.0, 1.0, size=(S, B, H)).astype(np.float32)
+        >>> cur_softmax_max = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
+        >>> cur_softmax_sum = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
+        >>> inputs_np = [prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum]
+        >>> inputs_ms = [Tensor(item) for item in inputs_np]
+        >>> out = ops.ring_attention_update(*inputs_ms)
+        >>> print(out[0].shape)
+        (4, 6, 16)
+    """
+    return ring_attention_update_op(prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum, actual_seq_qlen, layout)
+
+
 def rms_norm(x, gamma, epsilon=1e-6):
     r"""
     The RmsNorm(Root Mean Square Layer Normalization) operator is a normalization operation. Compared to
@@ -8093,7 +8437,7 @@ def scalar_cast(input_x, input_y):
 
     Args:
         input_x (scalar): The input scalar. Only constant value is allowed.
-        input_y (mindspore.dtype): The type to be cast. Only constant value is allowed. And the value should only be mindspore.int64, mindspore.float64, or mindspore.bool_.
+        input_y (mindspore.dtype): The type to be cast. Only constant value is allowed. And the value should only be mindspore.int64, mindspore.float64, or mindspore.bool.
 
     Returns:
         Scalar. The type is the same as the python type corresponding to `input_y`.
@@ -8603,6 +8947,58 @@ def sin(input):
     return sin_op(input)
 
 
+def smooth_l1_loss(prediction, target, beta=1.0, reduction='none'):
+    r"""
+    Calculate the smooth L1 loss, and the L1 loss function has robustness.
+
+    Refer to :func:`mindspore.ops.smooth_l1_loss` for more details.
+
+    .. warning::
+        This API has poor performance on CPU and it is recommended to run it on the Ascend/GPU.
+
+    Args:
+        beta (number, optional): A parameter used to control the point where the function will change between
+            L1 to L2 loss. Default: ``1.0`` .
+
+            - Ascend: The value should be equal to or greater than zero.
+            - CPU/GPU: The value should be greater than zero.
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'none'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+
+    Inputs:
+        - **logits** (Tensor) - Input Tensor of any dimension. Supported dtypes: 
+
+          - Ascend: float16, float32, bfloat16.
+          - CPU/GPU: float16, float32, float64.
+        - **labels** (Tensor) - Ground truth data.
+            
+          - CPU/Ascend: has the same shape as the `logits`, `logits` and `labels` comply with the implicit type conversion rules to make the data types consistent.
+          - GPU: has the same shape and dtype as the `logits`.
+
+    Outputs:
+        Tensor, if `reduction` is ``'none'``, then output is a tensor with the same shape as `logits`. Otherwise the shape of output tensor is :math:`()`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> loss = ops.SmoothL1Loss()
+        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
+        >>> output = loss(logits, labels)
+        >>> print(output)
+        [0.  0.  0.5]
+    """
+    return smooth_l1_loss_impl(prediction, target, beta, reduction)
+
+
 def softplus_ext(input, beta=1, threshold=20):
     r"""
     Applies softplus function to `input` element-wise.
@@ -8784,7 +9180,7 @@ def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False):
 
     Note:
         - `solve_triangular` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
+          does not support other usage scenarios.
         - `solve_triangular` is not supported on Windows platform yet.
 
     Args:
@@ -9062,11 +9458,11 @@ def sub_ext(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -9111,7 +9507,7 @@ def sub(input, other):
     Note:
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
         - Support implicit type conversion and type promotion.
 
     Args:
@@ -9215,9 +9611,6 @@ def swiglu(input, dim=-1):
     Computes SwiGLU (Swish-Gated Linear Unit activation function) of input tensor.
     SwiGLU is a variant of the :class:`mindspore.ops.GLU` activation function, it is defined as:
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     .. math::
         {SwiGLU}(a, b)= Swish(a) \otimes b
 
@@ -9225,6 +9618,9 @@ def swiglu(input, dim=-1):
     Swish(a)=a :math:`\sigma` (a), :math:`\sigma` is the :func:`mindspore.ops.sigmoid` activation function
     and :math:`\otimes` is the Hadamard product.
 
+    .. warning::
+        Only support on Atlas A2 training series.
+
     Args:
         input (Tensor): Tensor to be split. It has shape :math:`(\ast_1, N, \ast_2)`
             where `*` means, any number of additional dimensions. :math:`N` must be divisible by 2.
@@ -9457,6 +9853,30 @@ def topk_ext(input, k, dim=-1, largest=True, sorted=True):
     return topk_ext_op(input, k, dim, largest, sorted)
 
 
+def topprouter(input, capacity, expert_num, drop_type=0, threshold=0.0, router_prob=0.0):
+    r"""
+    TopPRouter implementation in MOE.
+
+    Inputs:
+        - **x** (Tensor) - Input Tensor of 3D, supporting types:[int32, int64]
+        - **capacity** (Int64) - The maximum number of tokens each expert can handle.
+        - **expert_num** (Int64) - The number of expert.
+        - **drop_type** (Int64) - S-Drop/K-Drop, 0 means S-Drop, 1 means K-Drop, default 0.
+        - **threshold** (float32) - Expert threshold, default 0.
+        - **router_prob** (Tensor) - Topk prob Tensor of 2D, supporting types:[float32], default 0.
+
+    Outputs:
+        tuple(Tensor), tuple of 2 tensors, `dispatch_index` and `combine_inex`.
+
+        - dispatch_index (Tensor) - Token ID processed by each expert.
+        - combine_index (Tensor) - The combine index of each token.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    return topprouter_op(input, capacity, expert_num, drop_type, threshold, router_prob)
+
+
 def trace_ext(input):
     r"""
     Returns a new tensor that is the sum of the `input` main trace.
@@ -10478,8 +10898,68 @@ def quant_batch_matmul(x1, x2, scale, offset=None, bias=None, pertokenScaleOptio
     return quant_batch_matmul_impl(x1, x2, scale, offset, bias, pertokenScaleOptional, transpose_x1, transpose_x2, dtype)
 
 
+def quant_matmul(x1, x2, scale, offset=None, pertoken_scale=None, bias=None, output_dtype=None, x1_dtype=None, x2_dtype=None, pertoken_scale_dtype=None, scale_dtype=None, group_sizes=None):
+    r"""
+    
+    """
+    return quant_matmul_op(x1, x2, scale, offset, pertoken_scale, bias, output_dtype, x1_dtype, x2_dtype, pertoken_scale_dtype, scale_dtype, group_sizes)
+
+
 def weight_quant_batch_matmul(x, weight, antiquant_scale, antiquant_offset=None, quant_scale=None, quant_offset=None, bias=None, transpose_x=False, transpose_weight=False, antiquant_group_size=0):
     r"""
     
     """
     return weight_quant_batch_matmul_impl(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size)
+
+
+def moe_token_unpermute(permuted_tokens, sorted_indices, probs=None, padded_mode=False, restore_shape=None):
+    r"""
+    Unpermute a tensor of permuted tokens based on sorted indices, and optionally merge the tokens with their corresponding probabilities.
+
+    .. warning::
+        - It is only supported on Atlas A2 Training Series Products.
+        - `sorted_indices` must not have duplicate values, otherwise the result is undefined.
+
+    Args:
+        permuted_tokens (Tensor): The tensor of permuted tokens to be unpermuted.
+            The shape is :math:`[num\_tokens * topk, hidden\_size]` , where `num_tokens`, `topk` and `hidden_size` are positive integers.
+        sorted_indices (Tensor): The tensor of sorted indices used to unpermute the tokens.
+            The shape is :math:`[num\_tokens * topk,]`, where `num_tokens` and `topk` are positive integers.
+            It only supports the int32 data type.
+        probs (Tensor, optional): The tensor of probabilities corresponding to the permuted tokens.
+            If provided, the unpermuted tokens will be merged with their respective probabilities.
+            The shape is :math:`[num\_tokens, topk]`, where `num_tokens` and `topk` are positive integers. Default: ``None`` .
+        padded_mode (bool, optional): If ``True``, indicating the indices are padded to denote selected tokens per expert. Default: ``False`` .
+        restore_shape (Union[tuple[int], list[int]], optional): The input shape before permutation, only used in padding mode. Default: ``None`` .
+
+    Returns:
+        Tensor, with the same dtype as `permuted_tokens`. If `padded_mode` is ``False``, the shape will be [`num_tokens`, `hidden_size`].
+        If `padded_mode` is ``True``, the shape will be specified by `restore_shape`.
+
+    Raises:
+        TypeError: If `permuted_tokens` is not a Tensor.
+        ValueError: Only supported when `padded_mode` is ``False``.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> permuted_token = Tensor([
+        ...                          [1, 1, 1],
+        ...                          [0, 0, 0],
+        ...                          [0, 0, 0],
+        ...                          [3, 3, 3],
+        ...                          [2, 2, 2],
+        ...                          [1, 1, 1],
+        ...                          [2, 2, 2],
+        ...                          [3, 3, 3]], dtype=mindspore.bfloat16)
+        >>> sorted_indices = Tensor([0, 6, 7, 5, 3, 1, 2, 4], dtype=mindspore.int32)
+        >>> out = ops.moe_token_unpermute(permuted_token, sorted_indices)
+        >>> out.shape
+        (8, 3)
+        
+        
+    """
+    return moe_token_unpermute_op(permuted_tokens, sorted_indices, probs, padded_mode, restore_shape)