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

mindspore/ops/function/array_func.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-2023 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.
@@ -24,6 +24,7 @@ import numpy as np
 import mindspore as ms
 import mindspore.common.dtype as mstype
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops.primitive import constexpr
 from mindspore.ops.primitive import _primexpr
 import mindspore.ops as ops
@@ -31,18 +32,19 @@ from mindspore.ops.operations._inner_ops import DynamicBroadcastTo
 from mindspore.ops.operations._sequence_ops import TupleToTensor
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops.operations._sequence_ops import TensorToList
+from mindspore.ops.auto_generate import OnesLikeExt, ZerosLikeExt, FillScalar, FillTensor, Arange, Chunk, UniqueDim,\
+    Unique2, SortExt, NonZero, NonZeroExt
+from mindspore.ops.auto_generate.gen_ops_prim import SplitTensor
+from mindspore.ops.auto_generate.gen_ops_prim import SplitWithSize, RepeatInterleaveInt, RepeatInterleaveTensor
 
 from mindspore.ops.operations.array_ops import (
     UniqueConsecutive,
     SearchSorted,
-    NonZero,
     MatrixDiagV3,
     MatrixDiagPartV3,
     MatrixSetDiagV3,
     Fills,
     Col2Im,
-    ArgMaxWithValue,
-    ArgMinWithValue,
     ScatterNdMax,
     ScatterNdMul,
     IndexFill,
@@ -52,7 +54,9 @@ from mindspore.ops.operations.array_ops import (
     Lstsq,
     Mvlgamma,
     Tril,
-    Argmax
+    Argmax,
+    ArgMaxWithValue,
+    ArgMinWithValue
 )
 from mindspore.ops.operations.array_ops import TensorScatterElements
 from mindspore.common import Tensor
@@ -61,53 +65,83 @@ from mindspore import _checkparam as validator
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore.ops._utils.utils import ms_arrange
 
-tuple_to_tensor_ = TupleToTensor()
+from mindspore.ops.auto_generate import cat, range, scatter_nd, deepcopy, masked_fill, diagonal, expand_dims, \
+    flip, transpose, triu, unsorted_segment_sum, diag, gather, gather_d, gather_nd, reshape, \
+    broadcast_to, strided_slice, ones, zeros, max_, min_, select
+from mindspore.ops.auto_generate.gen_ops_prim import scatter_add_ext_op, slice_ext_op
+from mindspore.ops.operations.manually_defined import tile, rank, scalar_cast
+
+arg_max_with_value_ = ArgMaxWithValue()
+arg_min_with_value_ = ArgMinWithValue()
+batch_to_space_nd_v2_ = P.BatchToSpaceNDV2()
+cast_ = P.Cast()
+diag_ = P.Diag()
+dynamic_broadcast_to_ = DynamicBroadcastTo()
 eye_ = P.Eye()
 fills_ = Fills()
+fillv2_ = P.FillV2()
+flatten_ = P.Flatten()
+gather_ = P.Gather()
+gather_d_ = P.GatherD()
+gather_nd_ = P.GatherNd()
+ger_ = P.Ger()
+index_fill_ = IndexFill()
+lstsq_ = Lstsq()
+masked_select_ = P.MaskedSelect()
+matrix_band_part_ = P.array_ops.MatrixBandPart()
 ones_ = P.Ones()
-ones_like_ = P.OnesLike()
-tile_ = P.Tile()
-unique_with_pad_ = P.UniqueWithPad()
-size_ = P.Size()
-shape_ = P.Shape()
+population_count_ = P.PopulationCount()
+range_ = P.Range()
 rank_ = P.Rank()
-tensor_shape_ = P.TensorShape()
+reduce_max_ = P.ReduceMax()
+reduce_min_ = P.ReduceMin()
 reshape_ = P.Reshape()
-tensor_slice = P.Slice()
-expand_dims_ = P.ExpandDims()
-transpose_ = P.Transpose()
+scalar_to_tensor_ = P.ScalarToTensor()
 scatter_add_ = P.ScatterAdd()
+scatter_div_ = P.ScatterDiv()
 scatter_max_ = P.ScatterMax()
 scatter_min_ = P.ScatterMin()
 scatter_mul_ = P.ScatterMul()
-scatter_div_ = P.ScatterDiv()
 scatter_nd_ = P.ScatterNd()
-gather_ = P.Gather()
-gather_d_ = P.GatherD()
-gather_nd_ = P.GatherNd()
-nonzero_ = NonZero()
-scalar_cast_ = P.ScalarCast()
+scatter_update_ = P.ScatterUpdate()
+shape_ = P.Shape()
+split_tensor = SplitTensor()
+split_with_size = SplitWithSize()
+size_ = P.Size()
 tensor_scatter_add_ = P.TensorScatterAdd()
-tensor_scatter_sub_ = P.TensorScatterSub()
-tensor_scatter_mul_ = P.TensorScatterMul()
 tensor_scatter_div_ = P.TensorScatterDiv()
-tensor_scatter_min_ = P.TensorScatterMin()
 tensor_scatter_max_ = P.TensorScatterMax()
-scalar_to_tensor_ = P.ScalarToTensor()
-tuple_to_array_ = P.TupleToArray()
-masked_select_ = P.MaskedSelect()
-matrix_band_part_ = P.array_ops.MatrixBandPart()
-ger_ = P.Ger()
-diag_ = P.Diag()
-range_ = P.Range()
-zeros_like_ = P.ZerosLike()
-cast_ = P.Cast()
+tensor_scatter_min_ = P.TensorScatterMin()
+tensor_scatter_mul_ = P.TensorScatterMul()
+tensor_scatter_sub_ = P.TensorScatterSub()
 tensor_select_ = P.Select()
-index_fill_ = IndexFill()
+tensor_shape_ = P.TensorShape()
+tensor_slice = P.Slice()
+tile_ = P.Tile()
+transpose_ = P.Transpose()
+tuple_to_array_ = P.TupleToArray()
+tuple_to_tensor_ = TupleToTensor()
+unique_ = P.Unique()
+unique_with_pad_ = P.UniqueWithPad()
+unsorted_segment_max_ = P.UnsortedSegmentMax()
+unsorted_segment_min_ = P.UnsortedSegmentMin()
+unsorted_segment_prod_ = P.UnsortedSegmentProd()
 unsorted_segment_sum_ = P.UnsortedSegmentSum()
-population_count_ = P.PopulationCount()
-reduce_max = P.ReduceMax()
-reduce_min = P.ReduceMin()
+ones_like_ = P.OnesLike()
+zeros_like_ = P.ZerosLike()
+ones_like_ext_ = OnesLikeExt()
+zeros_like_ext_ = ZerosLikeExt()
+fill_scalar_ = FillScalar()
+fill_tensor_ = FillTensor()
+sort_ext_ = SortExt()
+arange_ = Arange()
+chunk_ = Chunk()
+repeat_interleave_int_ = RepeatInterleaveInt()
+repeat_interleave_tensor_ = RepeatInterleaveTensor()
+unique_dim_ = UniqueDim()
+unique2_ = Unique2()
+non_zero_ = NonZero()
+non_zero_ext_ = NonZeroExt()
 
 
 @_primexpr
@@ -187,8 +221,11 @@ def arange(start=0, end=None, step=1, *, dtype=None):
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The required data type of returned Tensor. Default: ``None`` .
-            If the value is not specified or is ``None`` , the type with the highest precision in the
-            `start`, `end`, and `step` parameters is inferred.
+            When `dtype` is not specified or ``None``:
+
+            If `start`, `end`, and `step` are all integers, the dtype of output is int64,
+
+            If `start`, `end`, and `step` contain at least one floating-point number, the dtype of output is float32.
 
     Returns:
         A 1-D Tensor, with the same type as the inputs.
@@ -225,7 +262,7 @@ def arange(start=0, end=None, step=1, *, dtype=None):
         >>> print(output)
         [12. 11. 10.  9.  8.  7.  6.  5.  4.  3.]
         >>> print(output.dtype)
-        Float64
+        Float32
     """
     if end is None:
         start, end = 0, start
@@ -237,67 +274,84 @@ def arange(start=0, end=None, step=1, *, dtype=None):
     if start.shape != () or end.shape != () or step.shape != ():
         raise ValueError(f"For arange, the input args must be a TensorScalar,"
                          f" but got start shape:{start.shape}, end shape:{end.shape}, step shape:{step.shape}")
-    range_op = _get_cache_prim(P.Range)()
-    data = range_op(start, end, step)
+    data = range_(start, end, step)
     if dtype is not None:
         data = cast_(data, dtype)
     return data
 
 
-def cat(tensors, axis=0):
+def arange_ext(start=0, end=None, step=1, *, dtype=None):
     r"""
-    Connect input tensors along with the given axis.
+    Creates a sequence of numbers that begins at `start` and extends by increments of
+    `step` up to but not including `end`.
 
-    The input data is a tuple or a list of tensors. These tensors have the same rank :math:`R`.
-    Set the given axis as :math:`m`, and :math:`0 \le m < R`. Set the number of input tensors as :math:`N`.
-    For the :math:`i`-th tensor :math:`t_i`, it has the shape of :math:`(x_1, x_2, ..., x_{mi}, ..., x_R)`.
-    :math:`x_{mi}` is the :math:`m`-th dimension of the :math:`t_i`. Then, the shape of the output tensor is
+    Args:
+        start (Union[float, int], optional): The start of the interval. Default: ``0`` .
+        end (Union[float, int], optional): The end of the interval, exclusive.
+            Default: ``None`` . If ``None`` , it defaults to the value of `start`, and 0 is used as the starting value.
+        step (Union[float, int], optional): The step size with which the array element increments. Default: ``1`` .
 
-    .. math::
+    Keyword Args:
+        dtype (mindspore.dtype, optional): The required data type of returned Tensor. Default: ``None`` .
+            When `dtype` is not specified or ``None``:
 
-        (x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)
+            If `start`, `end`, and `step` are all integers, the dtype of output is int64,
 
-    Args:
-        tensors (Union[tuple, list]): A tuple or a list of input tensors.
-            Suppose there are two tensors in this tuple or list, namely t1 and t2.
-            To perform `concat` in the axis 0 direction, except for the :math:`0`-th axis,
-            all other dimensions should be equal, that is,
-            :math:`t1.shape[1] = t2.shape[1], t1.shape[2] = t2.shape[2], ..., t1.shape[R-1] = t2.shape[R-1]`,
-            where :math:`R` represents the rank of tensor.
-        axis (int): The specified axis, whose value is in range :math:`[-R, R)`. Default: ``0`` .
+            If `start`, `end`, and `step` contain at least one floating-point number, the dtype of output is float32.
 
     Returns:
-        Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
-            The data type is the same with `tensors`.
+        A 1-D Tensor, cast to `dtype` if provided, may potentially lose precision due to casting.
 
     Raises:
-        TypeError: If `axis` is not an int.
-        ValueError: If `tensors` have different dimension of tensor.
-        ValueError: If `axis` not in range :math:`[-R, R)`.
-        RuntimeError: If tensor's shape in `tensors` except for `axis` are different.
+        TypeError: If `start`, `end` or `step` are not of type int or float.
+        ValueError: If `step` = 0.
+        ValueError: If `start` >= `end` when `step` > 0.
+        ValueError: If `start` <= `end` when `step` < 0.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> import mindspore
-        >>> import numpy as np
+        >>> import mindspore as ms
         >>> from mindspore import Tensor, ops
-        >>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
-        >>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
-        >>> output = ops.cat((input_x1, input_x2))
+        >>> output = ops.arange_ext(1, 6)
         >>> print(output)
-        [[0. 1.]
-         [2. 1.]
-         [0. 1.]
-         [2. 1.]]
-        >>> output = ops.cat((input_x1, input_x2), 1)
+        [1 2 3 4 5]
+        >>> print(output.dtype)
+        Int64
+        >>> output = ops.arange_ext(0, 3, 1.2)
+        >>> print(output)
+        [0.  1.2 2.4]
+        >>> print(output.dtype)
+        Float32
+        >>> output = ops.arange_ext(7, 1, -2)
         >>> print(output)
-        [[0. 1. 0. 1.]
-         [2. 1. 2. 1.]]
+        [7 5 3]
+        >>> print(output.dtype)
+        Int64
+        >>> output = ops.arange_ext(12, 2, -1, dtype=ms.bfloat16))
+        >>> print(output)
+        [12. 11. 10.  9.  8.  7.  6.  5.  4.  3.]
+        >>> print(output.dtype)
+        BFloat16
+    """
+    if end is None:
+        start, end = 0, start
+    return arange_(start, end, step, dtype)
+
+
+def concat(tensors, axis=0):
+    """
+    Alias for :func:`mindspore.ops.cat()`.
+
+    Tutorial Examples:
+        - `Tensor - Tensor Operation <https://mindspore.cn/tutorials/en/master/beginner/tensor.html#tensor-operation>`_
+        - `Vision Transformer Image Classification - Building ViT as a whole
+          <https://mindspore.cn/tutorials/application/en/master/cv/vit.html#building-vit-as-a-whole>`_
+        - `Sentiment Classification Implemented by RNN - Dense
+          <https://mindspore.cn/tutorials/application/en/master/nlp/sentiment_analysis.html#dense>`_
     """
-    _concat = _get_cache_prim(P.Concat)(axis)
-    return _concat(tensors)
+    return cat(tensors, axis)
 
 
 def eye(n, m=None, dtype=None):
@@ -305,14 +359,14 @@ def eye(n, m=None, dtype=None):
     Creates a tensor with ones on the diagonal and zeros in the rest.
 
     Note:
-        Combines ReverseV2 operator to get an anti-diagonal Tensor,
-        but ReverseV2 only supports Ascend and GPU platforms currently.
+        The data type of returned tensor can be float16, float32, int8, int16, int32, int64, uint8
+        or bool on Ascend platforms.
 
     Args:
         n (int): The number of rows of returned tensor. Constant value only.
-        m (int): The number of columns of returned tensor. Constant value only.
+        m (int, optional): The number of columns of returned tensor. Constant value only.
             Default: ``None`` , if ``None`` , the number of columns is as the same as n.
-        dtype (mindspore.dtype): MindSpore's dtype, the data type of the returned tensor.
+        dtype (mindspore.dtype, optional): MindSpore's dtype, the data type of the returned tensor.
             The data type can be bool or Number.
             Default: ``None`` , the data type of the returned tensor is mindspore.float32.
 
@@ -336,11 +390,11 @@ def eye(n, m=None, dtype=None):
          [0 1]]
         >>> print(output.dtype)
         Int32
-        >>> output = ops.eye(1, 2, mindspore.float64)
+        >>> output = ops.eye(1, 2, mindspore.float32)
         >>> print(output)
         [[1. 0.]]
         >>> print(output.dtype)
-        Float64
+        Float32
         >>> output = ops.eye(2, dtype=mindspore.int32)
         >>> print(output)
         [[1 0]
@@ -419,25 +473,25 @@ def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype
     return out
 
 
-def where(condition, x, y):
+def where(condition, input, other):
     r"""
-    Selects elements from `x` or `y` based on `condition` and returns a tensor.
+    Selects elements from `input` or `other` based on `condition` and returns a tensor.
 
     .. math::
-        output_i = \begin{cases} x_i,\quad &if\ condition_i \\ y_i,\quad &otherwise \end{cases}
+        output_i = \begin{cases} input_i,\quad &if\ condition_i \\ other_i,\quad &otherwise \end{cases}
 
     Args:
-        condition (Tensor[bool]): If True, yield `x`, otherwise yield `y`.
-        x (Union[Tensor, Scalar]): When `condition` is True, values to select from.
-        y (Union[Tensor, Scalar]): When `condition` is False, values to select from.
+        condition (Tensor[bool]): If True, yield `input`, otherwise yield `other`.
+        input (Union[Tensor, Scalar]): When `condition` is True, values to select from.
+        other (Union[Tensor, Scalar]): When `condition` is False, values to select from.
 
     Returns:
-        Tensor, elements are selected from `x` and `y`.
+        Tensor, elements are selected from `input` and `other`.
 
     Raises:
         TypeError: If `condition` is not a Tensor.
-        TypeError: If both `x` and `y` are scalars.
-        ValueError: If `condition`, `x` and `y` can not broadcast to each other.
+        TypeError: If both `input` and `other` are scalars.
+        ValueError: If `condition`, `input` and `other` can not broadcast to each other.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -454,66 +508,15 @@ def where(condition, x, y):
         [[0. 1.]
          [2. 1.]]
     """
-    if not isinstance(condition, Tensor):
-        raise TypeError(f"For 'where', 'condition' must be a Tensor, but got {type(condition)}.")
-    if isinstance(x, (int, float)):
-        if not isinstance(y, Tensor):
-            raise TypeError(
-                f"For 'where', at least one of 'x' and 'y' should be Tensor, but got x:{type(x)}, y:{type(y)}."
-            )
-        x = cast_(x, y.dtype)
-    elif isinstance(y, (int, float)):
-        if not isinstance(x, Tensor):
-            raise TypeError(
-                f"For 'where', at least one of 'x' and 'y' should be Tensor, but got x:{type(x)}, y:{type(y)}."
-            )
-        y = cast_(y, x.dtype)
-    output_shape = _calc_broadcast_shape(x.shape, y.shape, condition.shape)
-    condition = broadcast_to(condition, output_shape)
-    x = broadcast_to(x, output_shape)
-    y = broadcast_to(y, output_shape)
-    _select = P.Select()
-    return _select(condition, x, y)
+    return tensor_select_(condition, input, other)
 
 
 def reverse(x, axis):
     """
-    Reverses specific dimensions of a tensor.
-
-    .. warning::
-        The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "input_x".
-
-    Args:
-        x (Tensor): The target tensor.
-            The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        axis (Union[tuple(int), list(int)]): The indices of the dimensions to reverse.
-
-    Outputs:
-        Tensor, has the same shape and type as `x`.
-
-    Raises:
-        TypeError: If `axis` is neither list nor tuple.
-        TypeError: If element of `axis` is not an int.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
-        >>> output = ops.reverse(input_x, axis=[1])
-        >>> print(output)
-        [[4 3 2 1]
-         [8 7 6 5]]
-        >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
-        >>> output = ops.reverse(input_x, axis=[1, 0])
-        >>> print(output)
-        [[8 7 6 5]
-         [4 3 2 1]]
+    :func:`mindspore.ops.reverse` will be deprecated in the future.
+    Please use :func:`mindspore.ops.flip` instead.
     """
-    return P.ReverseV2(axis)(x)
+    return flip(x, axis)
 
 
 def ravel(input):
@@ -659,8 +662,9 @@ def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
     other locations take value `off_value`.
 
     Note:
-        If the input indices is rank `N`, the output will have rank `N+1`. The new axis is created at dimension `axis`.
-        On Ascend, if `on_value` is Int64 dtype, `indices` must be Int64 dtype.
+        If the input `indices` has rank `N`, the output will have rank `N+1`.
+        The new axis is created at dimension `axis`. On Ascend, if `on_value` is int64 dtype, `indices` must be
+        int64 dtype, and the value for `on_value` and `off_value` can only be 1 and 0.
 
     Args:
         indices(Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
@@ -682,6 +686,7 @@ def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
     Raises:
         TypeError: If `axis` or `depth` is not an int.
         TypeError: If dtype of `indices` is not int32 or int64.
+        TypeError: If dtype of `on_value` is not int32, int64, float16 or float32.
         TypeError: If `indices`, `on_value` or `off_value` is not a Tensor.
         ValueError: If `axis` is not in range [-1, ndim].
         ValueError: If `depth` is less than 0.
@@ -715,8 +720,8 @@ def fill(type, shape, value):  # pylint: disable=redefined-outer-name
 
     Args:
         type (mindspore.dtype): The specified type of output tensor. The data type only supports
-            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ and
-            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ and
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ .
         shape (Union(Tensor, tuple[int])): The specified shape of output tensor.
         value (Union(Tensor, number.Number, bool)): Value to fill the returned tensor.
 
@@ -743,7 +748,7 @@ def fill(type, shape, value):  # pylint: disable=redefined-outer-name
          [0. 0. 0.]]
     """
     value = cast_(value, type)
-    return _get_cache_prim(P.FillV2)()(shape, value)
+    return fillv2_(shape, value)
 
 
 def full(size, fill_value, *, dtype=None):  # pylint: disable=redefined-outer-name
@@ -791,6 +796,45 @@ def full(size, fill_value, *, dtype=None):  # pylint: disable=redefined-outer-na
     return ops.fill(dtype, size, fill_value)
 
 
+def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-outer-name
+    """
+    Create a Tensor of the specified shape and fill it with the specified value.
+
+    Args:
+        size (Union(tuple[int], list[int])): The specified shape of output tensor.
+        fill_value (number.Number): Value to fill the returned tensor. Complex numbers are not supported for now.
+
+    Keyword Args:
+        dtype (mindspore.dtype): The specified type of output tensor. `bool_` and `number` are supported, for details,
+            please refer to :class:`mindspore.dtype` . Default: ``None`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `size` is not a tuple or list.
+        ValueError: The element in `size` is less than 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> output = ops.full((2, 2), 1)
+        >>> print(output)
+        [[1. 1.]
+         [1. 1.]]
+        >>> output = ops.full((3, 3), 0)
+        >>> print(output)
+        [[0. 0. 0.]
+         [0. 0. 0.]
+         [0. 0. 0.]]
+    """
+    if isinstance(fill_value, Tensor):
+        return fill_tensor_(size, fill_value, dtype)
+    return fill_scalar_(size, fill_value, dtype)
+
+
 def full_like(input, fill_value, *, dtype=None):
     """
     Return a Tensor of the same shape as `input` and filled with `fill_value`.
@@ -883,24 +927,63 @@ def chunk(input, chunks, axis=0):
     length_along_dim = arr_shape[arr_axis]
 
     if chunks > length_along_dim:
-        res = P.Split(arr_axis, length_along_dim)(input)
+        res = _get_cache_prim(P.Split)(arr_axis, length_along_dim)(input)
     elif length_along_dim % chunks == 0:
-        res = P.Split(arr_axis, chunks)(input)
+        res = _get_cache_prim(P.Split)(arr_axis, chunks)(input)
     else:
         block_size = int(np.ceil(length_along_dim / chunks))
         true_chunks = int(length_along_dim // block_size)
         length1 = true_chunks * block_size
         length2 = length_along_dim - length1
-        start1 = _list_comprehensions(rank(input), 0, True)
+        start1 = _list_comprehensions(rank_(input), 0, True)
         size1 = _tuple_setitem(arr_shape, arr_axis, length1)
         start2 = _tuple_setitem(start1, arr_axis, length1)
         size2 = _tuple_setitem(arr_shape, arr_axis, length2)
-        res = P.Split(arr_axis, true_chunks)(tensor_slice(input, start1, size1))
+        res = _get_cache_prim(P.Split)(arr_axis, true_chunks)(tensor_slice(input, start1, size1))
         if length2:
-            res += P.Split(arr_axis, 1)(tensor_slice(input, start2, size2))
+            res += _get_cache_prim(P.Split)(arr_axis, 1)(tensor_slice(input, start2, size2))
     return res
 
 
+def chunk_ext(input, chunks, dim=0):
+    """
+    Cut the input Tensor into `chunks` sub-tensors along the specified axis.
+
+    Note:
+        This function may return less than the specified number of chunks!
+
+    Args:
+        input (Tensor): A Tensor to be cut.
+        chunks (int): Number of sub-tensors to cut.
+        dim (int, optional): Specify the dimensions that you want to split. Default: ``0`` .
+
+    Returns:
+        A tuple of sub-tensors.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: The sum of `chunks` is not int.
+        TypeError: If argument `dim` is not int.
+        ValueError: If argument `dim` is out of range of :math:`[-input.ndim, input.ndim)` .
+        ValueError: If argument `chunks` is not positive number.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> input_x = np.arange(9).astype("float32")
+        >>> output = mindspore.mint.chunk(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Float32, value= [ 0.00000000e+00,  1.00000000e+00,  2.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    return chunk_(input, chunks, dim)
+
+
 def fills(x, value):
     """
     `fills` is deprecated, please use `ops.fill` instead.
@@ -920,50 +1003,6 @@ def fills(x, value):
     return fills_(x, value_)
 
 
-def ones(shape, dtype=None):  # pylint: disable=redefined-outer-name
-    r"""
-    Creates a tensor filled with value ones.
-
-    Creates a tensor with shape described by the first argument and fills it with value ones in type of the second
-    argument.
-
-    Args:
-        shape (Union[tuple[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
-            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
-            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
-        dtype (:class:`mindspore.dtype`): The specified type of output tensor. If `dtype` is ``None`` ,
-            `mindspore.float32` will be used. Default: ``None`` .
-
-    Returns:
-        Tensor, has the same type and shape as input shape value.
-
-    Raises:
-        TypeError: If `shape` is not tuple, int or Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> output = ops.ones((2, 2), mindspore.float32)
-        >>> print(output)
-        [[1. 1.]
-         [1. 1.]]
-    """
-    _dtype = mstype.float32 if dtype is None else dtype
-    ones_op = _get_cache_prim(P.FillV2)()
-    value = Tensor(1, _dtype)
-    if isinstance(shape, int):
-        shape = tuple([shape])
-    elif isinstance(shape, list):
-        shape = Tensor(shape, dtype=mstype.int64)
-    elif isinstance(shape, Tensor) and shape.ndim == 0 and shape.size == 1:
-        shape = shape.reshape(1)
-    output = ones_op(shape, value)
-    return output
-
-
 def ones_like(input, *, dtype=None):
     """
     Returns a Tensor with a value of 1 and its shape is the same as the input.
@@ -993,57 +1032,15 @@ def ones_like(input, *, dtype=None):
         [[1 1]
          [1 1]]
     """
-    ones_like_op = _get_cache_prim(P.OnesLike)()
-    output = ones_like_op(input)
+    output = ones_like_(input)
     _dtype = input.dtype if dtype is None else dtype
     output = cast_(output, _dtype)
     return output
 
 
-def zeros(size, dtype=None):  # pylint: disable=redefined-outer-name
-    r"""
-    Creates a tensor filled with 0 with shape described by `shape` and fills it with value 0 in type of `dtype`.
-
-    Args:
-        size (Union[tuple[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
-            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
-            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
-        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
-            mindspore.float32 will be used. Default: ``None`` .
-
-    Returns:
-        Tensor, has the same dtype and size as input.
-
-    Raises:
-        TypeError: If `size` is not tuple, int or Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> output = ops.zeros((2, 2), mindspore.float32)
-        >>> print(output)
-        [[0. 0.]
-         [0. 0.]]
-    """
-    zero_op = _get_cache_prim(P.FillV2)()
-    _dtype = mstype.float32 if dtype is None else dtype
-    value = Tensor(0, _dtype)
-    if isinstance(size, int):
-        size = tuple([size])
-    elif isinstance(size, list):
-        size = Tensor(size, dtype=mstype.int64)
-    elif isinstance(size, Tensor) and size.ndim == 0 and size.size == 1:
-        size = size.reshape(1)
-    output = zero_op(size, value)
-    return output
-
-
 def zeros_like(input, *, dtype=None):
     r"""
-    Creates a tensor filled with 0, with the same size as x, and the given dtype.
+    Creates a tensor filled with 0, with the same size as input, and the given dtype.
 
     If `dtype = None`, the tensor will have the same dtype as input `input`.
 
@@ -1074,125 +1071,78 @@ def zeros_like(input, *, dtype=None):
          [0. 0.]]
     """
     _dtype = input.dtype if dtype is None else dtype
-    _zeros_like = _get_cache_prim(P.ZerosLike)()
-    _cast = _get_cache_prim(P.Cast)()
-    output = _zeros_like(input)
-    output = _cast(output, _dtype)
+    output = zeros_like_(input)
+    output = cast_(output, _dtype)
     return output
 
 
-def tile(input, multiples):
-    r"""
-    Replicates an input tensor with given multiples times.
-
-    Creates a new tensor by replicating `input` `multiples` times. The i'th dimension of
-    output tensor has `input.shape[i] * multiples[i]` elements, and the values of `input`
-    are replicated `multiples[i]` times along the i'th dimension.
+def ones_like_ext(input, *, dtype=None):
+    """
+    Creates a tensor filled with 1, with the same shape as input, and its data type is determined by the given dtype.
 
-    Note:
-        The length of `multiples` must be greater or equal to the length of dimension in `input`.
+    If `dtype = None`, the tensor will have the same dtype as input `input`.
 
     Args:
-        input (Tensor): 1-D or higher dimensional Tensor. Set the shape of input tensor as
-            :math:`(x_1, x_2, ..., x_S)` .
+        input (Tensor): Tensor of any dimension.
 
-        multiples (tuple[int]): The parameter that specifies the number of replications,
-            the parameter type is tuple, and the data type is int, i.e., :math:`(y_1, y_2, ..., y_S)`.
-            The length of `multiples` cannot be smaller than the length of the shape of `input`.
-            Only constant value is allowed.
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype` is ``None`` ,
+            the dtype of the input tensor will be used. Default: ``None`` .
 
     Returns:
-        Tensor, has the same data type as the `input`. Suppose the length of `multiples` is `d`,
-        the dimension of `input` is `input.dim`, and the shape of `input` is :math:`(x_1, x_2, ..., x_S)`.
-
-        - If `input.dim = d`, then the shape of their corresponding positions can be multiplied, and
-          the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_S)`.
-        - If `input.dim < d`, fill in multiple 1 in the length of the shape of `input` until their
-          lengths are consistent. Such as set the shape of `input` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
-          then the shape of their corresponding positions can be multiplied, and the shape of Outputs is
-          :math:`(1*y_1, ..., x_R*y_R, x_S*y_S)`.
+        Tensor, has the same shape as `input` but filled with ones.
 
     Raises:
-        TypeError: If `multiples` is not a tuple or its elements are not all int.
-        ValueError: If the elements of `multiples` are not all greater than 0.
-        ValueError: If the length of `multiples` are smaller than the length of dimension in `input`.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
-        >>> multiples = (2, 3)
-        >>> output = ops.tile(input, multiples)
-        >>> print(output)
-        [[1.  2.  1.  2.  1.  2.]
-         [3.  4.  3.  4.  3.  4.]
-         [1.  2.  1.  2.  1.  2.]
-         [3.  4.  3.  4.  3.  4.]]
-        >>> multiples = (2, 3, 2)
-        >>> output = ops.tile(input, multiples)
-        >>> print(output)
-        [[[1. 2. 1. 2.]
-          [3. 4. 3. 4.]
-          [1. 2. 1. 2.]
-          [3. 4. 3. 4.]
-          [1. 2. 1. 2.]
-          [3. 4. 3. 4.]]
-         [[1. 2. 1. 2.]
-          [3. 4. 3. 4.]
-          [1. 2. 1. 2.]
-          [3. 4. 3. 4.]
-          [1. 2. 1. 2.]
-          [3. 4. 3. 4.]]]
-    """
-    tile_op = _get_cache_prim(P.Tile)()
-    return tile_op(input, multiples)
-
-
-def range(start, end, step):
+        >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
+        >>> output = ops.function.array_func.ones_like_ext(x)
+        >>> print(output)
+        [[1 1]
+         [1 1]]
+    """
+    return ones_like_ext_(input, dtype)
+
+
+def zeros_like_ext(input, *, dtype=None):
     r"""
-    Creates a sequence of numbers that begins at `start` and extends by increments of
-    `limit` up to but not including `end`.
+    Creates a tensor filled with 0, with the same size as input. Its data type is determined by the given dtype.
 
-    The types of all 3 inputs must be the same. The type of the resulting tensor is
-    the same as the type of the inputs.
+    If `dtype = None`, the tensor will have the same dtype as input `input`.
 
     Args:
-        start (Tensor): A scalar Tensor. The first number in the sequence. Must have
-          type: int32 ,int64, float32 or float64.
-        end (Tensor): A scalar Tensor. Upper limit of the sequence, exclusive. Must
-          have type: int32 ,int64, float32 or float64.
-        step (Tensor): A scalar Tensor. Number that increments `start`. Must have
-          type: int32 ,int64, float32 or float64.
+        input (Tensor): Tensor of any dimension.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype` is ``None`` ,
+            the dtype of the input tensor will be used. Default: ``None`` .
 
     Returns:
-        A 1-D Tensor, with the same type as the inputs.
+        Tensor, filled with 0.
 
     Raises:
-        TypeError: If `start`, `end` or `step` is not scalar Tensor.
-        TypeError: If datatype of `start`, `end` or `step` is not same.
-        TypeError: If datatype of `start`, `end` or `step` is not supported.
-        ValueError: If `step` = 0.
-        ValueError: If `start` >= `end` when `step` > 0.
-        ValueError: If `start` <= `end` when `step` < 0.
+        TypeError: If dtype is not a MindSpore dtype.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> start = Tensor(0, mstype.int32)
-        >>> end = Tensor(10, mstype.int32)
-        >>> step = Tensor(4, mstype.int32)
-        >>> output = ops.range(start, end, step)
+        >>> x = Tensor(np.arange(4).reshape(2, 2))
+        >>> output = ops.function.array_func.zeros_like_ext(x, dtype=mindspore.float32)
         >>> print(output)
-        [0 4 8]
+        [[0. 0.]
+         [0. 0.]]
     """
-    return range_(start, end, step)
+    return zeros_like_ext_(input, dtype)
 
 
 ##############################
@@ -1228,7 +1178,70 @@ def unique(input):
         TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
+        >>> output = ops.unique(x)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int32, value= [0, 1, 2, 1]))
+        >>> y = output[0]
+        >>> print(y)
+        [1 2 5]
+        >>> idx = output[1]
+        >>> print(idx)
+        [0 1 2 1]
+    """
+    shape_x = input.shape
+    length_x = get_x_shape(shape_x)
+    input = reshape_(input, length_x)
+    y, idx = unique_(input)
+    idx = reshape_(idx, shape_x)
+    return y, idx
+
+
+def unique_ext(input, sorted=True, return_inverse=False, return_counts=False, dim=None):
+    """
+    Returns the unique elements of input tensor.
+
+    when `return_inverse=True`, also return a tensor containing the index of each value of input
+    tensor corresponding to the output unique tensor.
+    when `return_counts=True`, also return a tensor containing the number of occurrences for each
+    unique value or tensor
+
+    Args:
+        input (Tensor): The input tensor.
+        sorted(bool): Whether to sort the unique elements in ascending order before returning as output.
+            Default: ``True`` .
+        return_inverse(bool): Whether to also return the indices for where elements in the original input ended up in
+            the returned unique list. Default: ``False`` .
+        return_counts(bool): Whether to also return the counts for each unique element. Default: ``False`` .
+        dim(int): the dimension to operate upon. If ``None``, the unique of the flattened input is returned.
+            Otherwise, each of the tensors indexed by the given dimension is treated as one of the elements to apply the
+            unique operation upon. Default: ``None`` .
+
+
+    Returns:
+        A tensor or a tuple of tensors containing some of tensor objects (`output`, `inverse_indices`, `counts`).
+
+        - output(Tensor) - The output tensor including the unique elements of input tensor, it has same dtype as input.
+        - inverse_indices(Tensor) - Return when ``return_inverse`` is True. It represents the indices for where
+          elements in the original input map to in the output. When ``dim`` is ``None``, it has same shape as input,
+          otherwise, the shape is input.shape[dim].
+        - counts(Tensor) - Return when ``return_counts`` is True. It represents the number of occurrences for each
+          unique value or tensor.  When ``dim`` is ``None``, it has same shape as output, otherwise, the shape is
+          output.shape(dim).
+
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
 
     Examples:
         >>> import mindspore
@@ -1236,9 +1249,9 @@ def unique(input):
         >>> from mindspore import Tensor, nn
         >>> from mindspore import ops
         >>> x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
-        >>> output = ops.unique(x)
+        >>> output = ops.unique_ext(x, return_inverse=True)
         >>> print(output)
-        (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int32, value= [0, 1, 2, 1]))
+        (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int64, value= [0, 1, 2, 1]))
         >>> y = output[0]
         >>> print(y)
         [1 2 5]
@@ -1246,16 +1259,20 @@ def unique(input):
         >>> print(idx)
         [0 1 2 1]
     """
-
-    unique_op = _get_cache_prim(P.Unique)()
-    reshape_op = _get_cache_prim(P.Reshape)()
-
-    shape_x = input.shape
-    length_x = get_x_shape(shape_x)
-    input = reshape_op(input, length_x)
-    y, idx = unique_op(input)
-    idx = reshape_op(idx, shape_x)
-    return y, idx
+    if not F.isconstant(return_inverse) or not F.isconstant(return_counts):
+        raise ValueError(f"For 'unique_ext', 'return_inverse' and 'return_counts' cannot be mutable")
+    if dim is None:
+        y, inverse, counts = unique2_(input, sorted, return_inverse, return_counts)
+    else:
+        validator.check_value_type("return_counts", return_counts, [bool], "unique_ext")
+        y, inverse, counts = unique_dim_(input, sorted, return_inverse, dim)
+    if return_inverse and return_counts:
+        return y, inverse, counts
+    if return_inverse:
+        return y, inverse
+    if return_counts:
+        return y, counts
+    return y
 
 
 def unique_with_pad(x, pad_num):
@@ -1363,7 +1380,7 @@ def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
     return output
 
 
-def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
+def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=None, sorter=None):
     """
     Return the position indices such that after inserting the values into the `sorted_sequence`, the order of innermost
     dimension of the `sorted_sequence` remains unchanged.
@@ -1378,16 +1395,24 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
             if ``False`` , the output datatype will be int64. Default: ``False`` .
         right (bool, optional): Search Strategy. If ``True`` , return the last suitable index found;
             if ``False`` , return the first such index. Default: ``False`` .
+        side (str, optional): the same as right but preferred. ``"left"`` corresponds to ``False`` for `right`
+            and ``"right"`` corresponds to ``True`` for `right`. An error will be reported if this parameter is
+            set to ``"left"`` while `right` is ``True``. Default: ``None`` .
+        sorter(Tensor, optional): if provided, a tensor matching the shape of the unsorted sorted_sequence
+            containing a sequence of indices that sort it in the ascending order on the innermost
+            dimension and type must be int64. Default: ``None`` .
 
     Returns:
         Tensor containing the indices from the innermost dimension of `sorted_sequence` such that,
-        if insert the corresponding value in the `values` tensor, the order of `sorted_sequence` would be preserved,
+        if insert the corresponding value in the `values` Tensor, the order of `sorted_sequence` would be preserved,
         whose datatype is int32 if out_int32 is ``True`` , otherwise int64, and shape is the same as the shape of
         `values`.
 
     Raises:
         ValueError: If the dimension of `sorted_sequence` isn't 1 and all dimensions except the last dimension of
             `sorted_sequence` and `values` are different.
+        ValueError: If `sorted_sequence` value is a scalar.
+        ValueError: If `values` is a scalar when `sorted_sequence` dimension is not 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1404,10 +1429,16 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
          [1 2 4]]
     """
 
-    _check_attr_dtype("out_int32", out_int32, [bool], "search_sorted")
-    dtype = mstype.int64 if not out_int32 else mstype.int32
+    validator.check_value_type("out_int32", out_int32, [bool], "search_sorted")
+    validator.check_value_type("right", right, [bool], "search_sorted")
+    dtype = mstype.int32 if bool(out_int32) else mstype.int64
+    if (side == "left" and right is True):
+        raise ValueError(f"For 'searchsorted', side and right can't be set to opposites,"
+                         f"got side of left while right was True.")
+    if side == "right":
+        right = True
     search_sorted_ = SearchSorted(dtype, right)
-    return search_sorted_(sorted_sequence, values)
+    return search_sorted_(sorted_sequence, values, sorter)
 
 
 def ger(input, vec2):
@@ -1457,7 +1488,7 @@ def size(input_x):
 
     Args:
         input_x (Tensor): Input parameters, the shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is
-            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -1538,76 +1569,6 @@ def dyn_shape(input_x):
     return tensor_shape_(input_x)
 
 
-def rank(input_x):
-    """
-    Returns the rank of a tensor.
-
-    Returns a 0-D int32 Tensor representing the rank of input; the rank of a tensor
-    is the number of indices required to uniquely select each element of the tensor.
-
-    Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is Number.
-
-    Returns:
-        Tensor. 0-D int32 Tensor representing the rank of input, i.e., :math:`R`. The data type is an int.
-
-    Raises:
-        TypeError: If `input_x` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> output = ops.rank(input_tensor)
-        >>> print(output)
-        2
-        >>> print(type(output))
-        <class 'int'>
-    """
-    return rank_(input_x)
-
-
-def reshape(input, shape):
-    """
-    Rearranges the input Tensor based on the given shape.
-
-    The 'shape' can only have one -1 at most, in which case it's inferred from the remaining dimensions and
-    the number of elements in the input.
-
-    Args:
-        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        shape (Union[tuple[int], Tensor[int]]): Constructed by multiple
-            integers, i.e., :math:`(y_1, y_2, ..., y_S)`. Only constant value is allowed.
-
-    Returns:
-        Tensor, the shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
-
-    Raises:
-        ValueError: Given a shape tuple, if it has several -1; or if the product
-            of its elements is less than or equal to 0 or cannot be divided by the product
-            of the input tensor shape; or if it does not match the input's array size.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> output = ops.reshape(input, (3, 2))
-        >>> print(output)
-        [[-0.1  0.3]
-         [ 3.6  0.4]
-         [ 0.5 -3.2]]
-    """
-    return reshape_(input, shape)
-
-
 def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
     r"""
     Reverses variable length slices.
@@ -1672,7 +1633,7 @@ def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
         [[4. 3. 2. 1.]
          [8. 7. 6. 5.]]
     """
-    return P.ReverseSequence(seq_dim=seq_dim, batch_dim=batch_dim)(x, seq_lengths)
+    return _get_cache_prim(P.ReverseSequence)(seq_dim=seq_dim, batch_dim=batch_dim)(x, seq_lengths)
 
 
 def flatten(input, order='C', *, start_dim=1, end_dim=-1):
@@ -1696,7 +1657,7 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     Raises:
         TypeError: If `input` is not a Tensor.
         TypeError: If `order` is not string type.
-        ValueError: If `order` is string type, but not 'C' or 'F'.
+        ValueError: If `order` is string type, but not ``'C'`` or ``'F'``.
         TypeError: If `start_dim` or `end_dim` is not int.
         ValueError: If `start_dim` is greater than `end_dim` after canonicalized.
         ValueError: If `start_dim` or `end_dim` is not in range of [-input.dim, input.dim-1].
@@ -1741,7 +1702,7 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
             return reshape_(input, (-1,))
         perm = ops.make_range(0, x_rank)
         new_order = ops.tuple_reversed(perm)
-        input = _get_cache_prim(P.Transpose)()(input, new_order)
+        input = transpose_(input, new_order)
 
     # Handle the default case.
     x_shape = shape_(input)
@@ -1749,7 +1710,7 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     if start_dim == 1 and end_dim == -1:
         if x_rank in (0, 1):
             return reshape_(input, (-1,))
-        return _get_cache_prim(P.Flatten)()(input)
+        return flatten_(input)
 
     # Check axis.
     start_dim = canonicalize_axis(start_dim, x_rank)
@@ -1771,341 +1732,6 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     return reshape_(input, new_shape)
 
 
-@constexpr
-def _check_select_type_match(scalar, tensor_type, scalar_name, tensor_name):
-    if isinstance(scalar, int) and tensor_type != mstype.int32:
-        raise TypeError(f"For functional operator[select], the input[{scalar_name}] is int, "
-                        f"then the input[{tensor_name}] must be a Tensor of int32.")
-    if isinstance(scalar, float) and tensor_type != mstype.float32:
-        raise TypeError(f"For functional operator[select], the input[{scalar_name}] is float, "
-                        f"then the input[{tensor_name}] must be a Tensor of float32.")
-
-
-@_primexpr
-def _check_select_shape_match(input_shape, cond_shape, tensor_name):
-    if input_shape != cond_shape:
-        raise ValueError(f"For functional operator[select], the cond shape must be same as {tensor_name} shape.")
-
-
-@constexpr
-def _check_select_type(is_cond_tensor, is_x_scalar, is_y_scalar, is_x_tensor, is_y_tensor):
-    if not is_cond_tensor:
-        raise TypeError(f"For functional operator[select], the input[cond] must be a Tensor.")
-    if is_x_scalar and not is_y_tensor:
-        raise TypeError(f"For functional operator[select], the input[x] is int or float, "
-                        f"then the input[y] must be a Tensor.")
-    if is_y_scalar and not is_x_tensor:
-        raise TypeError(f"For functional operator[select], the input[y] is int or float, "
-                        f"then the input[x] must be a Tensor.")
-
-
-@constexpr
-def _check_select_shape_same(cond_shape, x_shape, y_shape):
-    """Check if input of select has same shape."""
-    return cond_shape == x_shape and x_shape == y_shape and cond_shape == y_shape
-
-
-@constexpr
-def get_max_value(x, y, z):
-    """Get the maximum value of x, y and z."""
-    if x >= y and x >= z:
-        return x
-    if y >= x and y >= z:
-        return y
-    return z
-
-
-@constexpr
-def _calc_broadcast_shape(cond_shape, x_shape, y_shape):
-    """Calculate broadcast shape for select"""
-    converted_shape = []
-    cond_reverse = cond_shape[::-1]
-    x_reverse = x_shape[::-1]
-    y_reverse = y_shape[::-1]
-    max_len = get_max_value(len(cond_reverse), len(x_reverse), len(y_reverse))
-    i = 0
-    while i < max_len:
-        cond_element = 1 if i >= len(cond_reverse) else cond_reverse[i]
-        x_element = 1 if i >= len(x_reverse) else x_reverse[i]
-        y_element = 1 if i >= len(y_reverse) else y_reverse[i]
-        broadcast_element = get_max_value(cond_element, x_element, y_element)
-        if cond_element not in (1, broadcast_element):
-            raise ValueError(f"For select, condition input can not broadcast at index {i}")
-        if x_element not in (1, broadcast_element):
-            raise ValueError(f"For select, x input can not broadcast at index {i}")
-        if y_element not in (1, broadcast_element):
-            raise ValueError(f"For select, y input can not broadcast at index {i}")
-        converted_shape.append(broadcast_element)
-        i = i + 1
-    converted_shape.reverse()
-    return tuple(converted_shape)
-
-
-def select(cond, x, y):
-    r"""
-    The conditional tensor determines whether the corresponding element in the output must be
-    selected from `x` (if true) or `y` (if false) based on the value of each element.
-
-    It can be defined as:
-
-    .. math::
-        out_i = \begin{cases}
-        x_i, & \text{if } cond_i \\
-        y_i, & \text{otherwise}
-        \end{cases}
-
-    Args:
-        cond (Tensor[bool]): The condition tensor, decides which element is chosen.
-          The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-        x (Union[Tensor, int, float]): The first Tensor or number to be selected.
-          If x is a Tensor, the shape is or can be broadcadt to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-          If x is an int or a float, it will be cast to the type of int32 or float32,
-          and broadcast to the same shape as y. One of x and y must be a Tensor.
-        y (Union[Tensor, int, float]): The second Tensor or number to be selected.
-          If y is a Tensor, The shape is or can be broadcadt to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-          If y is an int or a float, it will be cast to the type of int32 or float32,
-          and broadcast to the same shape as x. One of x and y must be a Tensor.
-
-    Returns:
-        Tensor, has the same shape as `cond`.
-
-    Raises:
-        TypeError: If `x` or `y` is not a Tensor, int or float.
-        ValueError: The shapes of inputs can not be broadcast.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> # 1) Both inputs are Tensor
-        >>>
-        >>> cond = Tensor([True, False])
-        >>> x = Tensor([2,3], mindspore.float32)
-        >>> y = Tensor([1,2], mindspore.float32)
-        >>> output = ops.select(cond, x, y)
-        >>> print(output)
-        [2. 2.]
-        >>> # 2) y is a float
-        >>> cond = Tensor([True, False])
-        >>> x = Tensor([2,3], mindspore.float32)
-        >>> y = 2.0
-        >>> output = ops.select(cond, x, y)
-        >>> print(output)
-        [2. 2.]
-    """
-    is_x_scalar = isinstance(x, (int, float))
-    is_y_scalar = isinstance(y, (int, float))
-    is_x_tensor = isinstance(x, Tensor)
-    is_y_tensor = isinstance(y, Tensor)
-    is_cond_tensor = isinstance(cond, Tensor)
-    _check_select_type(is_cond_tensor, is_x_scalar, is_y_scalar, is_x_tensor, is_y_tensor)
-    input_x = x
-    input_y = y
-    if is_x_scalar:
-        _check_select_shape_match(y.shape, cond.shape, "y")
-        _check_select_type_match(x, y.dtype, "x", "y")
-        input_x = zeros_like_(y) + x
-        if isinstance(x, int):
-            input_x = cast_(input_x, mstype.int32)
-        else:
-            input_x = cast_(input_x, mstype.float32)
-
-    if is_y_scalar:
-        _check_select_shape_match(x.shape, cond.shape, "x")
-        _check_select_type_match(y, x.dtype, "y", "x")
-        input_y = zeros_like_(x) + y
-        if isinstance(y, int):
-            input_y = cast_(input_y, mstype.int32)
-        else:
-            input_y = cast_(input_y, mstype.float32)
-
-    if is_x_tensor and is_y_tensor and is_cond_tensor:
-        x_shape = ops.shape(x)
-        y_shape = ops.shape(y)
-        cond_shape = ops.shape(cond)
-        all_constant = ops.isconstant(cond_shape) and ops.isconstant(x_shape) and ops.isconstant(y_shape)
-        if all_constant and not _check_select_shape_same(cond_shape, x_shape, y_shape):
-            broadcast_shape = _calc_broadcast_shape(cond_shape, x_shape, y_shape)
-            new_cond = ops.broadcast_to(cond, broadcast_shape)
-            new_x = ops.broadcast_to(x, broadcast_shape)
-            new_y = ops.broadcast_to(y, broadcast_shape)
-            return tensor_select_(new_cond, new_x, new_y)
-
-    return tensor_select_(cond, input_x, input_y)
-
-
-def strided_slice(input_x,
-                  begin,
-                  end,
-                  strides,
-                  begin_mask=0,
-                  end_mask=0,
-                  ellipsis_mask=0,
-                  new_axis_mask=0,
-                  shrink_axis_mask=0):
-    r"""
-    Extracts a strided slice of a Tensor based on `begin/end` index and `strides`.
-
-    This operation extracts a fragment of size (end-begin)/strides from the given 'input_tensor'.
-    Starting from the beginning position, the fragment continues adding strides to the index until
-    all dimensions are not less than the ending position.
-
-    Note:
-        - `begin` , `end` and `strides` must have the same shape.
-        - `begin` , `end` and `strides` are all 1-D Tensor,  and their shape size
-          must not greater than the dim of `input_x`.
-
-    During the slicing process, the fragment (end-begin)/strides are extracted from each dimension.
-
-    Example: For Tensor `input_x` with shape :math:`(5, 6, 7)`,
-    set `begin`, `end` and `strides` to (1, 3, 2), (3, 5, 6),
-    (1, 1, 2) respectively, then elements from index 1 to 3 are extrected for dim 0, index 3 to 5
-    are extrected for dim 1 and index 2 to 6 with a `stirded` of 2 are extrected for dim 2, this
-    process is equivalent to a pythonic slice `input_x[1:3, 3:5, 2:6:2]`.
-
-    If the length of `begin` 、 `end` and `strides` is smaller than the dim of `input_x`,
-    then all elements are extracted from the missing dims, it behaves like all the
-    missing dims are filled with zeros, size of that missing dim and ones.
-
-    Example: For Tensor `input_x` with shape :math:`(5, 6, 7)`,
-    set `begin`, `end` and `strides` to (1, 3),
-    (3, 5), (1, 1) respectively, then elements from index 1 to 3 are extrected
-    for dim 0, index 3 to 5 are extrected for dim 1 and index 3 to 5 are extrected
-    for dim 2, this process is equivalent to a pythonic slice `input_x[1:3, 3:5, 0:7]`.
-
-    Here's how a mask works:
-    For each specific mask, it will be converted to a binary representation internally, and then
-    reverse the result to start the calculation. For Tensor `input_x` with
-    shape :math:`(5, 6, 7)`. Given mask value of 3 which
-    can be represented as 0b011. Reverse that we get 0b110, which implies the first and second dim of the
-    original Tensor will be effected by this mask. See examples below, for simplicity all mask mentioned
-    below are all in their reverted binary form:
-
-    - `begin_mask` and `end_mask`
-
-      If the ith bit of `begin_mask` is 1, `begin[i]` is ignored and the fullest
-      possible range in that dimension is used instead. `end_mask` is analogous,
-      except with the end range. For Tensor `input_x` with shape :math:`(5, 6, 7, 8)`,  if `begin_mask`
-      is 0b110, `end_mask` is 0b011, the slice `input_x[0:3, 0:6, 2:7:2]` is produced.
-
-    - `ellipsis_mask`
-
-      If the ith bit of `ellipsis_mask` is 1, as many unspecified dimensions as needed
-      will be inserted between other dimensions. Only one non-zero bit is allowed
-      in `ellipsis_mask`. For Tensor `input_x` with shape :math:`(5, 6, 7, 8)`,  `input_x[2:,...,:6]`
-      is equivalent to `input_x[2:5,:,:,0:6]` ,  `input_x[2:,...]` is equivalent
-      to `input_x[2:5,:,:,:]`.
-
-    - `new_axis_mask`
-
-      If the ith bit of `new_axis_mask` is 1, `begin`, `end` and `strides` are
-      ignored and a new length 1 dimension is added at the specified position
-      in the output Tensor. For Tensor `input_x` with shape :math:`(5, 6, 7)`, if `new_axis_mask`
-      is 0b110,  a new dim is added to the second dim, which will produce
-      a Tensor with shape :math:`(5, 1, 6, 7)`.
-
-    - `shrink_axis_mask`
-
-      If the ith bit of `shrink_axis_mask` is 1, `begin`, `end` and `strides`
-      are ignored and dimension i will be shrunk to 0.
-      For Tensor `input_x` with shape :math:`(5, 6, 7)`,
-      if `shrink_axis_mask` is 0b010, it is equivalent to slice `x[:, 5, :]`
-      and results in an output shape of :math:`(5, 7)`.
-
-    Note:
-        `new_axis_mask` and  `shrink_axis_mask` are not recommended to
-        use at the same time, it might incur unexpected result.
-
-    Args:
-        input_x (Tensor): The input Tensor to be extracted from.
-        begin (tuple[int]): A tuple which represents the location where to start.
-        end (tuple[int]): A tuple or which represents the maximum location where to end.
-        strides (tuple[int]): A tuple which represents the strides is continuously added
-            before reaching the maximum location. Only int is allowed, it can be negative
-            which results in reversed slicing.
-        begin_mask (int, optional): Starting index of the slice. Default: ``0`` .
-        end_mask (int, optional): Ending index of the slice. Default: ``0`` .
-        ellipsis_mask (int, optional): An int mask, ignore slicing operation when set to 1. Default: ``0`` .
-        new_axis_mask (int, optional): An int mask for adding new dims. Default: ``0`` .
-        shrink_axis_mask (int, optional): An int mask for shrinking dims. Default: ``0`` .
-
-    Returns:
-        Tensor, return the extracts a strided slice of a Tensor based on `begin/end` index and `strides`.
-
-    Raises:
-        TypeError: If `begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask` or
-            `shrink_axis_mask` is not an int.
-        TypeError: If `begin`, `end` or `strides` is not tuple[int].
-        ValueError: If `begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask` or
-            `shrink_axis_mask` is less than 0.
-        ValueError: If `begin`, `end` and `strides` have different shapes.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
-        ...                   [[5, 5, 5], [6, 6, 6]]], mindspore.float32)
-        >>> output = ops.strided_slice(input_x, (1, 0, 2), (3, 1, 3), (1, 1, 1))
-        >>> # Take this " output = strided_slice(input_x, (1, 0, 2), (3, 1, 3), (1, 1, 1)) " as an example,
-        >>> # start = [1, 0, 2] , end = [3, 1, 3], strides = [1, 1, 1], Find a segment of (start, end),
-        >>> # note that end is an open interval
-        >>> # To facilitate understanding, this operator can be divided into three steps:
-        >>> # Step 1: Calculation of the first dimension:
-        >>> # start = 1, end = 3, strides = 1, So can take 1st, 2nd rows, and then gets the final output at this time.
-        >>> # output_1th =
-        >>> # [
-        >>> #     [
-        >>> #         [3,3,3]
-        >>> #         [4,4,4]
-        >>> #     ]
-        >>> #     [
-        >>> #         [5,5,5]
-        >>> #         [6,6,6]
-        >>> #     ]
-        >>> # ]
-        >>> # Step 2: Calculation of the second dimension
-        >>> # 2nd dimension, start = 0, end = 1, strides = 1. So only 0th rows
-        >>> # can be taken, and the output at this time.
-        >>> # output_2nd =
-        >>> # [
-        >>> #     [
-        >>> #         [3,3,3]
-        >>> #     ]
-        >>> #     [
-        >>> #         [5,5,5]
-        >>> #     ]
-        >>> # ]
-        >>> # Step 3: Calculation of the third dimension
-        >>> # 3nd dimension,start = 2, end = 3, strides = 1, So can take 2th cols,
-        >>> # and you get the final output at this time.
-        >>> # output_3ed =
-        >>> # [
-        >>> #     [
-        >>> #         [3]
-        >>> #     ]
-        >>> #     [
-        >>> #         [5]
-        >>> #     ]
-        >>> # ]
-        >>> # The final output after finishing is:
-        >>> print(output)
-        [[[3.]]
-         [[5.]]]
-        >>> # another example like :
-        >>> output = strided_slice(input_x, (1, 0, 0), (2, 1, 3), (1, 1, 1))
-        >>> print(output)
-        [[[3. 3. 3.]]]
-    """
-    strided_slice_ = _get_cache_prim(P.StridedSlice)(
-        begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask)
-    return strided_slice_(input_x, begin, end, strides)
-
-
 def slice(input_x, begin, size):
     r"""
     Slices a tensor in the specified shape.
@@ -2160,20 +1786,6 @@ def slice(input_x, begin, size):
     return tensor_slice(input_x, begin, size)
 
 
-def concat(tensors, axis=0):
-    """
-    Alias for :func:`mindspore.ops.cat()`.
-
-    Tutorial Examples:
-        - `Tensor - Tensor Operation <https://mindspore.cn/tutorials/en/r2.2/beginner/tensor.html#tensor-operation>`_
-        - `Vision Transformer Image Classification - Building ViT as a whole
-          <https://mindspore.cn/tutorials/application/en/r2.2/cv/vit.html#building-vit-as-a-whole>`_
-        - `Sentiment Classification Implemented by RNN - Dense
-          <https://mindspore.cn/tutorials/application/en/r2.2/nlp/sentiment_analysis.html#dense>`_
-    """
-    return cat(tensors, axis)
-
-
 def stack(tensors, axis=0):
     r"""
     Stacks a list of tensors in specified axis.
@@ -2284,45 +1896,6 @@ def unbind(input, dim=0):
     return _unstack(input)
 
 
-def expand_dims(input_x, axis):
-    """
-    Adds an additional dimension to `input_x` at the given axis, the dimension
-    of `input_x` should be greater than or equal to 1.
-
-    Note:
-        If the specified axis is a negative number, the index is counted
-        backward from the end and starts at 1.
-
-    Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        axis (int): Specifies the dimension index at which to expand
-            the shape of `input_x`. The value of axis must be in the range
-            `[-input_x.ndim-1, input_x.ndim]`. Only constant value is allowed.
-
-    Returns:
-        Tensor, the shape of tensor is :math:`(1, x_1, x_2, ..., x_R)` if the
-        value of `axis` is 0. It has the same data type as `input_x`.
-
-    Raises:
-        TypeError: If `axis` is not an int.
-        ValueError: If `axis` is not in the valid range :math:`[-a.ndim-1, a.ndim]`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> output = ops.expand_dims(input_tensor, 0)
-        >>> print(output)
-        [[[2. 2.]
-          [2. 2.]]]
-    """
-    return expand_dims_(input_x, axis)
-
-
 def unsqueeze(input, dim):
     """
     Adds an additional dimension to `input` at the given dim.
@@ -2354,7 +1927,7 @@ def unsqueeze(input, dim):
         [[[2. 2.]
           [2. 2.]]]
     """
-    return expand_dims_(input, dim)
+    return expand_dims(input, dim)
 
 
 def squeeze(input, axis=None):
@@ -2411,57 +1984,6 @@ def squeeze(input, axis=None):
     return squeeze_(input)
 
 
-def transpose(input, input_perm):
-    """
-    Permutes the dimensions of the input tensor according to input permutation.
-
-    For a 1-D array this has no effect, as a transposed vector is simply the same vector.
-    To convert a 1-D array into a 2D column vector please refer the class: mindspore.ops.ExpandDims.
-    For a 2-D array, this is a standard matrix transpose. For an n-D array, if axes are given,
-    their order indicates how the axes are permuted (see Examples).
-    If axes are not provided and a.shape is :math:`(i[0], i[1], ... i[n-2], i[n-1])`,
-    then a.transpose().shape is :math:`(i[n-1], i[n-2], ... i[1], i[0])`.
-
-    Note:
-        On GPU and CPU, if the value of `input_perm` is negative, its actual value is `input_perm[i] + rank(input)`.
-        Negative value of `input_perm` is not supported on Ascend.
-
-    Args:
-        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        input_perm (tuple[int]): The permutation to be converted. The elements in `input_perm` are composed of
-            the indexes of each dimension of `input`. The length of `input_perm` and the shape of `input` must be
-            the same. Only constant value is allowed. Must be in the range [-rank(input), rank(input)).
-
-    Returns:
-        Tensor, the type of output tensor is the same as `input` and the shape of output tensor is decided by the
-        shape of `input` and the value of `input_perm`.
-
-    Raises:
-        TypeError: If `input_perm` is not a tuple.
-        ValueError: If length of shape of `input` is not equal to length of shape of `input_perm`.
-        ValueError: If the same element exists in `input_perm`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
-        >>> input_perm = (0, 2, 1)
-        >>> output = ops.transpose(input, input_perm)
-        >>> print(output)
-        [[[ 1.  4.]
-          [ 2.  5.]
-          [ 3.  6.]]
-         [[ 7. 10.]
-          [ 8. 11.]
-          [ 9. 12.]]]
-    """
-    return transpose_(input, input_perm)
-
-
 def scatter_mul(input_x, indices, updates):
     r"""
     Using given values to update tensor value through the mul operation, along with the input indices.
@@ -2792,111 +2314,6 @@ def scatter_div(input_x, indices, updates):
     return scatter_div_(input_x, indices, updates)
 
 
-def scatter_nd(indices, updates, shape):
-    r"""
-    Scatters a tensor into a new tensor depending on the specified indices.
-
-    Creates an empty tensor with the given `shape`, and set values by scattering the update tensor
-    depending on indices. The empty tensor has rank :math:`P` and `indices` has rank :math:`Q`.
-
-    The `shape` is :math:`(s_0, s_1, ..., s_{P-1})`, where :math:`P \ge 1`.
-
-    `indices` has shape :math:`(i_0, i_1, ..., i_{Q-2}, N)`, where :math:`Q \ge 2` and :math:`N \le P`.
-
-    The last dimension of `indices` (with length :math:`N` ) indicates slices along the :math:`N` th dimension of the
-    empty tensor.
-
-    `updates` is a tensor of rank :math:`Q-1+P-N`, and
-    its shape is :math:`(i_0, i_1, ..., i_{Q-2}, s_N, s_{N+1}, ..., s_{P-1})`.
-
-    If `indices` contains duplicates, the duplicate `updates` are summed.
-
-    The following figure shows the calculation process of inserting two new value matrices into the first dimension
-    with rank-3:
-
-    .. image:: ScatterNd.png
-
-    Args:
-        indices (Tensor): Define the index of scattering in the new tensor with int32 or int64 data type.
-            The rank of `indices` must be at least 2 and `indices.shape[-1] <= len(shape)`.
-        updates (Tensor): Define the source Tensor to be updated.
-            It has shape `indices.shape[:-1] + shape[indices.shape[-1]:]`.
-        shape (tuple[int]): Define the shape of the output tensor, has the same data type as indices.
-            `shape` can not be empty, and the elements in `shape` must be greater than or equal to 1.
-
-    Returns:
-        Tensor, the new tensor, has the same type as `update` and the same shape as `shape`.
-
-    Raises:
-        TypeError: If `shape` is not a tuple.
-        ValueError: If any element of `shape` is less than 1.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> indices = Tensor(np.array([[0], [2]]), mindspore.int32)
-        >>> updates = Tensor(np.array([[[1, 1, 1, 1], [2, 2, 2, 2],
-        ...                             [3, 3, 3, 3], [4, 4, 4, 4]],
-        ...                            [[1, 1, 1, 1], [2, 2, 2, 2],
-        ...                             [3, 3, 3, 3], [4, 4, 4, 4]]]), mindspore.float32)
-        >>> shape = (4, 4, 4)
-        >>> output = ops.scatter_nd(indices, updates, shape)
-        >>> print(output)
-        [[[1. 1. 1. 1.]
-          [2. 2. 2. 2.]
-          [3. 3. 3. 3.]
-          [4. 4. 4. 4.]]
-         [[0. 0. 0. 0.]
-          [0. 0. 0. 0.]
-          [0. 0. 0. 0.]
-          [0. 0. 0. 0.]]
-         [[1. 1. 1. 1.]
-          [2. 2. 2. 2.]
-          [3. 3. 3. 3.]
-          [4. 4. 4. 4.]]
-         [[0. 0. 0. 0.]
-          [0. 0. 0. 0.]
-          [0. 0. 0. 0.]
-          [0. 0. 0. 0.]]]
-        >>> indices = Tensor(np.array([[0, 1], [1, 1]]), mindspore.int32)
-        >>> updates = Tensor(np.array([3.2, 1.1]), mindspore.float32)
-        >>> shape = (3, 3)
-        >>> output = ops.scatter_nd(indices, updates, shape)
-        >>> # In order to facilitate understanding, explain the operator pseudo-operation process step by step:
-        >>> # Step 1: Generate an empty Tensor of the specified shape according to the shape
-        >>> # [
-        >>> #     [0. 0. 0.]
-        >>> #     [0. 0. 0.]
-        >>> #     [0. 0. 0.]
-        >>> # ]
-        >>> # Step 2: Modify the data at the specified location according to the indicators
-        >>> # 0th row of indices is [0, 1], 0th row of updates is 3.2.
-        >>> # means that the empty tensor in the 0th row and 1st col set to 3.2
-        >>> # [
-        >>> #     [0. 3.2. 0.]
-        >>> #     [0. 0.   0.]
-        >>> #     [0. 0.   0.]
-        >>> # ]
-        >>> # 1th row of indices is [1, 1], 1th row of updates is 1.1.
-        >>> # means that the empty tensor in the 1th row and 1st col set to 1.1
-        >>> # [
-        >>> #     [0. 3.2. 0.]
-        >>> #     [0. 1.1  0.]
-        >>> #     [0. 0.   0.]
-        >>> # ]
-        >>> # The final result is as follows:
-        >>> print(output)
-        [[0. 3.2 0.]
-         [0. 1.1 0.]
-         [0. 0.  0.]]
-    """
-    return scatter_nd_(indices, updates, shape)
-
-
 def scatter_update(input_x, indices, updates):
     r"""
     Updates tensor values by using input indices and value.
@@ -2946,8 +2363,7 @@ def scatter_update(input_x, indices, updates):
         [[2. 1.2  1.]
          [3. 1.2  1.]]
     """
-    scatter_update_inner = _get_cache_prim(P.ScatterUpdate)()
-    return scatter_update_inner(input_x, indices, updates)
+    return scatter_update_(input_x, indices, updates)
 
 
 def scatter_nd_add(input_x, indices, updates, use_locking=False):
@@ -3414,8 +2830,8 @@ def sort(input_x, axis=-1, descending=False):
             are sorted in descending order, or else sorted in ascending order. Default: ``False`` .
 
     .. warning::
-        Currently, the data types of Float16, UInt8, Int8, Int16, Int32, Int64 are well supported.
-        If use Float32, it may cause loss of accuracy.
+        Currently, the data types of float16, uint8, int8, int16, int32, int64 are well supported.
+        If use float32, it may cause loss of accuracy.
 
     Returns:
 
@@ -3452,129 +2868,72 @@ def sort(input_x, axis=-1, descending=False):
     return _sort(input_x)
 
 
-def argsort(input, axis=-1, descending=False):
+def sort_ext(input, *, dim=-1, descending=False, stable=False):
     r"""
-    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
+    Sorts the elements of the input tensor along the given dimension in the specified order.
+
+    .. warning::
+        Currently, the data types of float16, uint8, int8, int16, int32, int64 are well supported.
+        If use float32, it may cause loss of accuracy.
 
     Args:
         input(Tensor): The input tensor to sort.
-        axis (int): The axis to sort along. Default: ``-1`` , means the last dimension.
-            The Ascend backend only supports sorting the last dimension.
-        descending (bool): The sort order. If `descending` is True then the elements
-            are sorted in descending order by value. Otherwise sort in ascending order. Default: ``False`` .
-
-    Returns:
-        Tensor, the indices of sorted input tensor. Data type is int32.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-        >>> sort = ops.argsort(x)
-        >>> print(sort)
-        [[2 1 0]
-         [2 0 1]
-         [0 1 2]]
-    """
-    _sort = _get_cache_prim(P.Sort)(axis, descending)
-    _, arg_sort = _sort(input)
-    return arg_sort
-
-
-def gather(input_params, input_indices, axis, batch_dims=0):
-    r"""
-    Returns the slice of the input tensor corresponding to the elements of `input_indices` on the specified `axis`.
-
-    The following figure shows the calculation process of Gather commonly:
-
-    .. image:: Gather.png
-
-    where params represents the input `input_params`, and indices represents the index to be sliced `input_indices`.
-
-    .. note::
-        1. 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.
-
-        2. The data type of input_params cannot be
-           `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ on Ascend
-           platform currently.
+            The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
-    Args:
-        input_params (Tensor): The original Tensor. The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        input_indices (Tensor): Index tensor to be sliced, the shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
-            Specifies the indices of elements of the original Tensor. The data type can be int32 or int64.
-        axis (Union(int, Tensor[int])): Specifies the dimension index to gather indices.
-                                        It must be greater than or equal to `batch_dims`.
-                                        When `axis` is a Tensor, the size must be 1.
-        batch_dims (int): Specifies the number of batch dimensions. It must be less than or euqal to the rank
-                          of `input_indices`. Default: ``0`` .
+    Keyword Args:
+        dim (int, optional): The dimension to sort along. Default: ``-1``, means the last dimension.
+        descending (bool, optional): Controls the sort order. If `descending` is True, the elements
+            are sorted in descending order, or else sorted in ascending order. Default: ``False`` .
+        stable (bool, optional): Controls the sort order. If stable is True then the sorting routine
+            becomes stable, preserving the order of equivalent elements. Default: ``False`` .
 
     Returns:
-        Tensor, the shape of tensor is
-        :math:`input\_params.shape[:axis] + input\_indices.shape[batch\_dims:] + input\_params.shape[axis + 1:]`.
+        - y1, a tensor whose values are the sorted values, with the same shape and data type as input.
+        - y2, a tensor that consists of the indices of the elements in the original input tensor.
+          Data type is int64.
 
     Raises:
-        TypeError:  If `axis` is not an int or Tensor.
-        ValueError: If `axis` is a Tensor and its size is not 1.
-        TypeError:  If `input_params` is not a tensor.
-        TypeError:  If `input_indices` is not a tensor of type int.
-        RuntimeError: If `input_indices` is out of range `[0, input_param.shape[axis])` on CPU or GPU.
+        TypeError: If `dim` is not an int.
+        TypeError: If `descending` is not a bool.
+        TypeError: If `input` not in float16, float32, uint8, int8, int16, int32, int64, bfloat16
+        TypeError: If `stable` is not a bool.
+        ValueError: If `dim` is not in range of [-len(input_x.shape), len(input_x.shape)).
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> # case1: input_indices is a Tensor with shape (5, ).
-        >>> input_params = Tensor(np.array([1, 2, 3, 4, 5, 6, 7]), mindspore.float32)
-        >>> input_indices = Tensor(np.array([0, 2, 4, 2, 6]), mindspore.int32)
-        >>> axis = 0
-        >>> output = ops.gather(input_params, input_indices, axis)
-        >>> print(output)
-        [1. 3. 5. 3. 7.]
-        >>> # case2: input_indices is a Tensor with shape (2, 2). When the input_params has one dimension,
-        >>> # the output shape is equal to the input_indices shape.
-        >>> input_indices = Tensor(np.array([[0, 2], [2, 6]]), mindspore.int32)
-        >>> axis = 0
-        >>> output = ops.gather(input_params, input_indices, axis)
-        >>> print(output)
-        [[1. 3.]
-         [3. 7.]]
-        >>> # case3: input_indices is a Tensor with shape (2, ) and
-        >>> # input_params is a Tensor with shape (3, 4) and axis is 0.
-        >>> input_params = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]), mindspore.float32)
-        >>> input_indices = Tensor(np.array([0, 2]), mindspore.int32)
-        >>> axis = 0
-        >>> output = ops.gather(input_params, input_indices, axis)
-        >>> print(output)
-        [[ 1.  2.  3.  4.]
-         [ 9. 10. 11. 12.]]
-        >>> # case4: input_indices is a Tensor with shape (2, ) and
-        >>> # input_params is a Tensor with shape (3, 4) and axis is 1, batch_dims is 1.
-        >>> input_params = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]), mindspore.float32)
-        >>> input_indices = Tensor(np.array([0, 2, 1]), mindspore.int32)
-        >>> axis = 1
-        >>> batch_dims = 1
-        >>> output = ops.gather(input_params, input_indices, axis, batch_dims)
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> output = ops.function.array_func.sort_ext(x)
+        >>> # The output below is based on the Ascend platform.
         >>> print(output)
-        [ 1.  7. 10.]
+        (Tensor(shape=[3, 3], dtype=Float16, value=
+        [[ 1.0000e+00,  2.0000e+00,  8.0000e+00],
+        [ 3.0000e+00,  5.0000e+00,  9.0000e+00],
+        [ 4.0000e+00,  6.0000e+00,  7.0000e+00]]), Tensor(shape=[3, 3], dtype=Int64, value=
+        [[2, 1, 0],
+        [2, 0, 1],
+        [0, 1, 2]]))
     """
-    _gather = _get_cache_prim(P.Gather)(batch_dims)
-    return _gather(input_params, input_indices, axis)
+    return sort_ext_(input, dim, descending, stable)
 
 
-def gather_d(x, dim, index):
-    """
-    Gathers elements along an axis specified by dim.
+def argsort(input, axis=-1, descending=False):
+    r"""
+    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
+
+    Args:
+        input(Tensor): The input tensor to sort.
+        axis (int): The axis to sort along. Default: ``-1`` , means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
+        descending (bool): The sort order. If `descending` is True then the elements
+            are sorted in descending order by value. Otherwise sort in ascending order. Default: ``False`` .
 
-    Refer to :func:`mindspore.ops.gather_elements` for more detail.
+    Returns:
+        Tensor, the indices of sorted input tensor. Data type is int32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3583,15 +2942,16 @@ def gather_d(x, dim, index):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)
-        >>> index = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int32)
-        >>> dim = 1
-        >>> output = ops.gather_d(x, dim, index)
-        >>> print(output)
-        [[1 1]
-         [4 3]]
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> sort = ops.argsort(x)
+        >>> print(sort)
+        [[2 1 0]
+         [2 0 1]
+         [0 1 2]]
     """
-    return gather_d_(x, dim, index)
+    _sort = _get_cache_prim(P.Sort)(axis, descending)
+    _, arg_sort = _sort(input)
+    return arg_sort
 
 
 def gather_elements(input, dim, index):
@@ -3608,26 +2968,29 @@ def gather_elements(input, dim, index):
 
         output[i][j][k] = x[i][j][index[i][j][k]]  # if dim == 2
 
-    `input` and `index` have the same length of dimensions, and all dimensions except `dim` have the same size.
-    If `dim` = i, `input` is an n-D tensor with shape :math:`(z_0, z_1, ..., z_i, ..., z_{n-1})`,
-    the `index` must be an n-D tensor with shape :math:`(z_0, z_1, ..., y, ..., z_{n-1})`
-    where `y`>=1 and the output will have the same shape with `index`.
+    `input` and `index` have the same length of dimensions, and `index.shape[axis] <= input.shape[axis]`
+    where axis goes through all dimensions of `input` except `dim`.
+
+    .. warning::
+        On Ascend, the behavior is unpredictable in the following cases:
+
+        - the value of `index` is not in the range `[-input.shape[dim], input.shape[dim])` in forward;
+        - the value of `index` is not in the range `[0, input.shape[dim])` in backward.
 
     Args:
         input (Tensor): The input tensor.
-        dim (int): The axis along which to index. It must be int32 or int64. The value range is [-input.ndim,
-            input.ndim).
+        dim (int): The axis along which to index. It must be int32 or int64. The value range is `[-input.ndim,
+            input.ndim)`.
         index (Tensor): The indices of elements to gather. It can be one of the following data types:
-            int32, int64. The value range of each index element is [-input.shape(dim), input.shape(dim)).
+            int32, int64. The value range of each index element is `[-input.shape(dim), input.shape(dim))`.
 
     Returns:
-        Tensor, has the same shape as index tensor, the shape of tensor is :math:`(z_0, z_1, ..., y, ..., z_{n-1})`,
-        and has the same data type with `input`.
+        Tensor, has the same shape as `index` and has the same data type with `input`.
 
     Raises:
         TypeError: If dtype of `dim` or `index` is neither int32 nor int64.
         ValueError: If length of shape of `input` is not equal to length of shape of `index`.
-        ValueError: If the size of the dimension except `dim` is not equal between `input` and `index`.
+        ValueError: If the size of the dimension except `dim` in `input` is less than size in `index`.
         ValueError: If the value of `dim` is not in the expected range.
 
     Supported Platforms:
@@ -3648,48 +3011,6 @@ def gather_elements(input, dim, index):
     return gather_d_(input, dim, index)
 
 
-def gather_nd(input_x, indices):
-    r"""
-    Gathers slices from a tensor by indices.
-
-    Using given indices to gather slices from a tensor with a specified shape.
-
-    `indices` is an K-dimensional integer tensor. Supposes it as a (K-1)-dimensional tensor and each element of it
-    defines a slice of `input_x`:
-
-    .. math::
-        output[(i_0, ..., i_{K-2})] = input\_x[indices[(i_0, ..., i_{K-2})]]
-
-    The last dimension of `indices` can not more than the rank of `input_x`:
-    :math:`indices.shape[-1] <= input\_x.rank`.
-
-    Args:
-        input_x (Tensor): The target tensor to gather values.
-        indices (Tensor): The index tensor, with int32 or int64 data type.
-
-    Returns:
-        Tensor, has the same type as `input_x` and the shape is
-        :math:`indices\_shape[:-1] + input\_x\_shape[indices\_shape[-1]:]`.
-
-    Raises:
-        ValueError: If length of shape of `input_x` is less than the last dimension of `indices`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
-        >>> output = ops.gather_nd(input_x, indices)
-        >>> print(output)
-        [-0.1  0.5]
-    """
-    return gather_nd_(input_x, indices)
-
-
 def tensor_scatter_add(input_x, indices, updates):
     r"""
     Creates a new tensor by adding the values from the positions in `input_x` indicated by
@@ -3700,7 +3021,7 @@ def tensor_scatter_add(input_x, indices, updates):
 
     The last axis of `indices` is the depth of each index vectors. For each index vector,
     there must be a corresponding value in `updates`. The shape of `updates` should be
-    equal to the shape of `input_x[indices]`. For more details, see use cases.
+    equal to the shape of `input_x[indices]`. For more details, see Examples.
 
     .. math::
         output\left [indices  \right ] = input\_x + update
@@ -3758,7 +3079,7 @@ def tensor_scatter_sub(input_x, indices, updates):
 
     The last axis of `indices` is the depth of each index vectors. For each index vector,
     there must be a corresponding value in `updates`. The shape of `updates` should be
-    equal to the shape of `input_x[indices]`. For more details, see use cases.
+    equal to the shape of `input_x[indices]`. For more details, see Examples.
 
     .. math::
         output[indices] = input\_x - update
@@ -3943,14 +3264,12 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
           nondeterministic.
         - On Ascend, the reduction only support set to "none" for now.
         - On Ascend, the data type of `input_x` must be float16 or float32.
+        - This is an experimental API that is subject to change or deletion.
 
     Note:
         If some values of the `indices` exceed the upper or lower bounds of the index of `input_x`, instead of raising
         an index error, the corresponding `updates` will not be updated to `input_x`.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input_x (Tensor): The target tensor. The rank must be at least 1.
         indices (Tensor): The index of `input_x` to do scatter operation whose data type must be mindspore.int32 or
@@ -4065,6 +3384,79 @@ def scatter(input, axis, index, src):
     return ops.tensor_scatter_elements(input_x=input, indices=index, updates=src, axis=axis)
 
 
+def scatter_add_ext(input, dim, index, src):
+    """
+    Add all elements in `src` to the index specified by `index` to `input` along dimension specified by `dim`.
+    It takes three inputs `input`, `src` and `index` of the same rank r >= 1.
+
+    For a 3-D tensor, the operation updates input as follows:
+
+    .. code-block::
+
+        input[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
+
+        input[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
+
+        input[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2
+
+    Args:
+        input (Tensor): The target tensor. The rank must be at least 1.
+        dim (int): Which dim to scatter. Accepted range is [-r, r) where r = rank(`input`). Default: ``0``.
+        index (Tensor): The index of `input` to do scatter operation whose data type must be mindspore.int32 or
+            mindspore.int64. Same rank as `input`. Except for the dimension specified by `dim`,
+            the size of each dimension of `index` must be less than or equal to the size of
+            the corresponding dimension of `input`.
+        src (Tensor): The tensor doing the scatter operation with `input`, has the same type as `input` and
+            the size of each dimension must be greater than or equal to that of `index`.
+
+    Returns:
+        Tensor, has the same shape and type as `input`.
+
+    Raises:
+        TypeError: If `index` is neither int32 nor int64.
+        ValueError: If anyone of the rank among `input`, `index` and `src` less than 1.
+        ValueError: If the rank of `input`, `index` and `src` is not the same.
+        ValueError: If, outside dimension `dim`, the size of any dimension of `index` is greater than the size of
+            the corresponding dimension of `input` .
+        ValueError: If the size of any dimension of `src` is less than that of `index`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2, 3, 4, 5]]), dtype=ms.float32)
+        >>> src = Tensor(np.array([[8, 8]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[2, 4]]), dtype=ms.int64)
+        >>> out = ops.function.array_func.scatter_add_ext(input=input, dim=1, index=index, src=src)
+        >>> print(out)
+        [[1. 2. 11. 4. 13.]]
+        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[0, 0, 0], [2, 2, 2], [4, 4, 4]]), dtype=ms.int64)
+        >>> out = ops.function.array_func.scatter_add_ext(input=input, dim=0, index=index, src=src)
+        >>> print(out)
+        [[1. 2. 3. 0. 0.]
+         [0. 0. 0. 0. 0.]
+         [4. 5. 6. 0. 0.]
+         [0. 0. 0. 0. 0.]
+         [7. 8. 9. 0. 0.]]
+        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[0, 2, 4], [0, 2, 4], [0, 2, 4]]), dtype=ms.int64)
+        >>> out = ops.function.array_func.scatter_add_ext(input=input, dim=1, index=index, src=src)
+        >>> print(out)
+        [[1. 0. 2. 0. 3.]
+         [4. 0. 5. 0. 6.]
+         [7. 0. 8. 0. 9.]
+         [0. 0. 0. 0. 0.]
+         [0. 0. 0. 0. 0.]]
+    """
+    return scatter_add_ext_op(input, dim, index, src)
+
+
 def _get_slice_scatter_const(x_shape, axis, start, end, step):
     r"""
     Calculate the rank of input, embedded dimensions and index.
@@ -4074,7 +3466,7 @@ def _get_slice_scatter_const(x_shape, axis, start, end, step):
     start = start if start is not None else 0
     start = start if start >= 0 else start + x_rank
     end = end if end is not None else x_shape[axis]
-    end = end if end >= 0 else end + x_rank
+    end = end if end >= 0 else end + x_shape[axis]
     end = end if end < x_shape[axis] else x_shape[axis]
     index = list(builtins.range(start, end, step))
     return x_rank, index, axis
@@ -4121,6 +3513,8 @@ def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
          [1. 0. 1. 0. 1. 0.]
          [1. 0. 1. 0. 1. 0.]]
     """
+    _check_is_tensor("input", input, "slice_scatter")
+    _check_is_tensor("src", src, "slice_scatter")
     input_shape = input.shape
     input_rank, index, axis = _get_slice_scatter_const(input_shape, axis, start, end, step)
 
@@ -4136,6 +3530,8 @@ def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
     for _ in builtins.range(input_rank - axis - 1):
         index_tensor = index_tensor.expand_dims(-1)
     index_tensor = index_tensor.broadcast_to(src.shape)
+    if index_tensor.dtype not in mstype.int_type:
+        index_tensor = index_tensor.astype(mstype.int64)
     return tensor_scatter_elements(input, axis=axis, indices=index_tensor, updates=src)
 
 
@@ -4174,10 +3570,12 @@ def select_scatter(input, src, axis, index):
           [1. 1. 1.]
           [0. 0. 0.]]]
     """
+    _check_is_tensor("input", input, "select_scatter")
+    _check_is_tensor("src", src, "select_scatter")
     src = src.expand_dims(axis=axis)
     x_rank = input.ndim
     axis = axis if axis >= 0 else axis + x_rank
-    index = index if index >= 0 else index + x_rank
+    index = index if index >= 0 else index + input.shape[axis]
     return slice_scatter(input, src, axis, start=index, end=index + 1)
 
 
@@ -4228,6 +3626,7 @@ def space_to_batch_nd(input_x, block_size, paddings):
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> block_size = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
@@ -4302,49 +3701,11 @@ def batch_to_space_nd(input_x, block_shape, crops):
            [3.  4.]]]]
     """
     if isinstance(block_shape, Tensor):
-        _batch_to_space_ndv2 = _get_cache_prim(P.BatchToSpaceNDV2)()
-        return _batch_to_space_ndv2(input_x, block_shape, crops)
+        return batch_to_space_nd_v2_(input_x, block_shape, crops)
     _batch_to_space_nd = _get_cache_prim(P.BatchToSpaceND)(block_shape, crops)
     return _batch_to_space_nd(input_x)
 
 
-def nonzero(input):
-    """
-    Return a Tensor of the positions of all non-zero values.
-
-    Args:
-        input (Tensor): The input Tensor, its rank should be greater than or eaqual to 1.
-
-    Returns:
-        Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
-
-    Raises:
-        TypeError: If `input` is not Tensor.
-        ValueError: If dim of `x` equals to 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
-        >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
-        >>> output = ops.nonzero(x)
-        >>> print(output)
-        [[0 0 0]
-         [0 1 0]]
-        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
-        >>> output = ops.nonzero(x)
-        >>> print(output)
-        [[0]
-         [2]
-         [4]]
-    """
-    return nonzero_(input)
-
-
 def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_LEFT"):
     r"""
     Returns a Tensor with the contents in `x` as k[0]-th to k[1]-th diagonals of a matrix, with everything else padded
@@ -4604,18 +3965,19 @@ def meshgrid(*inputs, indexing='xy'):
 
     Keyword Args:
         indexing (str, optional): Cartesian ('xy', default) or
-            matrix ('ij') indexing of output. Valid options: xy' or 'ij'. In the 2-D case with
+            matrix ('ij') indexing of output. Valid options: xy' or ``'ij'``. In the 2-D case with
             inputs of length `M` and `N`, the outputs are of shape :math:`(N, M)`
-            for 'xy' indexing and :math:`(M, N)` for 'ij' indexing. In the 3-D
+            for ``'xy'`` indexing and :math:`(M, N)` for ``'ij'`` indexing. In the 3-D
             case with inputs of length `M`, `N` and `P`, outputs are of shape
-            :math:`(N, M, P)` for 'xy' indexing and :math:`(M, N, P)` for 'ij' indexing. Default: ``'xy'`` .
+            :math:`(N, M, P)` for ``'xy'`` indexing and :math:`(M, N, P)` for ``'ij'`` indexing.
+            Default: ``'xy'`` .
 
     Returns:
         Tensors, a Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
 
     Raises:
         TypeError: If `indexing` is not a str or `inputs` is not a tuple.
-        ValueError: If `indexing` is neither 'xy' nor 'ij'.
+        ValueError: If `indexing` is neither ``'xy'`` nor ``'ij'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4623,7 +3985,7 @@ def meshgrid(*inputs, indexing='xy'):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> x = Tensor(np.array([1, 2, 3, 4]).astype(np.int32))
         >>> y = Tensor(np.array([5, 6, 7]).astype(np.int32))
         >>> z = Tensor(np.array([8, 9, 0, 1, 2]).astype(np.int32))
@@ -4706,7 +4068,7 @@ def affine_grid(theta, size, align_corners=False):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> theta = Tensor([[[0.8, 0.5, 0],[-0.5, 0.8, 0]]], mindspore.float32)
         >>> out_size = (1, 3, 2, 3)
         >>> output = ops.affine_grid(theta, out_size, False)
@@ -4722,87 +4084,6 @@ def affine_grid(theta, size, align_corners=False):
     return affine_grid_op(theta, size)
 
 
-def broadcast_to(input, shape):  # pylint: disable=redefined-outer-name
-    """
-    Broadcasts input tensor to a given shape. The dim of input shape must be smaller
-    than or equal to that of target shape. Suppose input shape is :math:`(x_1, x_2, ..., x_m)`,
-    target shape is :math:`(*, y_1, y_2, ..., y_m)`, where :math:`*` means any additional dimension.
-    The broadcast rules are as follows:
-
-    Compare the value of :math:`x_m` and :math:`y_m`, :math:`x_{m-1}` and :math:`y_{m-1}`, ...,
-    :math:`x_1` and :math:`y_1` consecutively and
-    decide whether these shapes are broadcastable and what the broadcast result is.
-
-    If the value pairs at a specific dim are equal, then that value goes right into that dim of output shape.
-    With an input shape :math:`(2, 3)`, target shape :math:`(2, 3)` , the inferred output shape is :math:`(2, 3)`.
-
-    If the value pairs are unequal, there are three cases:
-
-    Case 1: If the value of the target shape in the dimension is -1, the value of the
-    output shape in the dimension is the value of the corresponding input shape in the dimension.
-    With an input shape :math:`(3, 3)`, target
-    shape :math:`(-1, 3)`, the output shape is :math:`(3, 3)`.
-
-    Case 2: If the value of target shape in the dimension is not -1, but the corresponding
-    value in the input shape is 1, then the corresponding value of the output shape
-    is that of the target shape. With an input shape :math:`(1, 3)`, target
-    shape :math:`(8, 3)`, the output shape is :math:`(8, 3)`.
-
-    Case 3: If the corresponding values of the two shapes do not satisfy the above cases,
-    it means that broadcasting from the input shape to the target shape is not supported.
-
-    So far we got the last m dims of the outshape, now focus on the first :math:`*` dims, there are
-    two cases:
-
-    If the first :math:`*` dims of output shape does not have -1 in it, then fill the input
-    shape with ones until their length are the same, and then refer to
-    Case 2 mentioned above to calculate the output shape. With target shape :math:`(3, 1, 4, 1, 5, 9)`,
-    input shape :math:`(1, 5, 9)`, the filled input shape will be :math:`(1, 1, 1, 1, 5, 9)` and thus the
-    output shape is :math:`(3, 1, 4, 1, 5, 9)`.
-
-    If the first :math:`*` dims of output shape have -1 in it, it implies this -1 is corresponding to
-    a non-existing dim so they're not broadcastable. With target shape :math:`(3, -1, 4, 1, 5, 9)`,
-    input shape :math:`(1, 5, 9)`, instead of operating the dim-filling process first, it raises errors directly.
-
-    Args:
-        input (Tensor): The input Tensor.
-        shape (tuple): The target shape to broadcast. Can be fully specified, or have -1 in one position
-                       where it will be substituted by the input tensor's shape in that position, see example.
-
-    Returns:
-        Tensor, with the given `shape` and the same data type as `input`.
-
-    Raises:
-        TypeError: If `shape` is not a tuple.
-        ValueError: If the target and input shapes are incompatible, or if a - 1 in the target shape is in an invalid
-                    location.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> shape = (2, 3)
-        >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
-        >>> output = ops.broadcast_to(x, shape)
-        >>> print(output)
-        [[1. 2. 3.]
-         [1. 2. 3.]]
-        >>> shape = (-1, 2)
-        >>> x = Tensor(np.array([[1], [2]]).astype(np.float32))
-        >>> output = ops.broadcast_to(x, shape)
-        >>> print(output)
-        [[1. 1.]
-         [2. 2.]]
-    """
-    if isinstance(shape, Tensor) or ops.is_sequence_value_unknown(shape):
-        _dyn_broadcast_to = _get_cache_prim(DynamicBroadcastTo)()
-        return _dyn_broadcast_to(input, shape)
-    _broadcast_to = _get_cache_prim(P.BroadcastTo)(shape)
-    return _broadcast_to(input)
-
-
 def unsorted_segment_min(x, segment_ids, num_segments):
     r"""
     Computes the minimum of a tensor along segments.
@@ -4826,14 +4107,13 @@ def unsorted_segment_min(x, segment_ids, num_segments):
         x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`. With float16, float32 or int32 data type.
         segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
             Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
-        num_segments (int): The value specifies the number of distinct `segment_ids`.
+        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
 
     Returns:
-        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+        Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
 
     Raises:
         TypeError: If `num_segments` is not an int.
-        ValueError: If length of shape of `segment_ids` is not equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4850,7 +4130,6 @@ def unsorted_segment_min(x, segment_ids, num_segments):
         [[1. 2. 3.]
          [4. 2. 1.]]
     """
-    unsorted_segment_min_ = P.UnsortedSegmentMin()
     return unsorted_segment_min_(x, segment_ids, num_segments)
 
 
@@ -4877,14 +4156,13 @@ def unsorted_segment_max(x, segment_ids, num_segments):
         x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`. With float16, float32 or int32 data type.
         segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
             Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
-        num_segments (int): The value specifies the number of distinct `segment_ids`.
+        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
 
     Returns:
-        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+        Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
 
     Raises:
         TypeError: If `num_segments` is not an int.
-        ValueError: If length of shape of `segment_ids` is not equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4901,7 +4179,6 @@ def unsorted_segment_max(x, segment_ids, num_segments):
         [[1. 2. 3.]
          [4. 5. 6.]]
     """
-    unsorted_segment_max_ = P.UnsortedSegmentMax()
     return unsorted_segment_max_(x, segment_ids, num_segments)
 
 
@@ -4919,16 +4196,15 @@ def unsorted_segment_prod(x, segment_ids, num_segments):
 
     Args:
         x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`. With float16, float32 or int32 data type.
-        segment_ids (Tensor): A `1-D` tensor whose shape is :math:`(x_1)`,
-                              the value must be non-negative tensor. The data type must be int32.
-        num_segments (int): The value specifies the number of distinct `segment_ids`.
+        segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
+            Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R. The data type must be int32.
+        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
 
     Returns:
-        Tensor, set the number of `num_segments` as `N`, the shape is :math:`(N, x_2, ..., x_R)`.
+        Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
 
     Raises:
         TypeError: If `num_segments` is not an int.
-        ValueError: If length of shape of `segment_ids` is not equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4945,7 +4221,6 @@ def unsorted_segment_prod(x, segment_ids, num_segments):
         [[4. 4. 3.]
          [4. 5. 6.]]
     """
-    unsorted_segment_prod_ = P.UnsortedSegmentProd()
     return unsorted_segment_prod_(x, segment_ids, num_segments)
 
 
@@ -4986,7 +4261,7 @@ def index_fill(x, axis, index, value):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32))
         >>> index = Tensor([0, 2], mindspore.int32)
@@ -5157,33 +4432,6 @@ def is_nonzero(input):
     return bool(out)
 
 
-def scalar_cast(input_x, input_y):
-    """
-    Casts the input scalar to another type.
-
-    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.
-
-    Returns:
-        Scalar. The type is the same as the python type corresponding to `input_y`.
-
-    Raises:
-        TypeError: If neither `input_x` nor `input_y` is a constant value.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> output = ops.scalar_cast(255.0, mindspore.int32)
-        >>> print(output)
-        255
-    """
-    return scalar_cast_(input_x, input_y)
-
-
 def tensor_scatter_mul(input_x, indices, updates):
     r"""
     Creates a new tensor by multiplying the values from the positions in `input_x` indicated by
@@ -5193,10 +4441,10 @@ def tensor_scatter_mul(input_x, indices, updates):
 
     The last axis of `indices` is the depth of each index vectors. For each index vector,
     there must be a corresponding value in `updates`. The shape of `updates` should be
-    equal to the shape of `input_x[indices]`. For more details, see use cases.
+    equal to the shape of `input_x[indices]`. For more details, see Examples.
 
     .. math::
-        output[indices] = input\_x \times update
+        output\left [indices  \right ] = input\_x\times  update
 
     Note:
         - If some values of the `indices` are out of bound, instead of raising an index error,
@@ -5253,7 +4501,7 @@ def tensor_scatter_div(input_x, indices, updates):
 
     The last axis of `indices` is the depth of each index vectors. For each index vector,
     there must be a corresponding value in `updates`. The shape of `updates` should be
-    equal to the shape of `input_x[indices]`. For more details, see use cases.
+    equal to the shape of `input_x[indices]`. For more details, see Examples.
 
     .. math::
         output\left [indices  \right ] = input\_x \div update
@@ -5374,113 +4622,36 @@ def tuple_to_array(input_x):
     return tuple_to_tensor_(input_x, dtype)
 
 
-def masked_select(input, mask):
-    """
-    Returns a new 1-D Tensor which indexes the `x` tensor according to the boolean `mask`.
-    The shapes of the `mask` tensor and the `x` tensor don't need to match, but they must be broadcastable.
-
-    Args:
-        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        mask (Tensor[bool]): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-    Returns:
-        A 1-D Tensor, with the same type as `input`.
-
-    Raises:
-        TypeError: If `input` or `mask` is not a Tensor.
-        TypeError: If dtype of `mask` is not bool.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore.ops as ops
-        >>> from mindspore import Tensor
-        >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
-        >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
-        >>> output = ops.masked_select(x, mask)
-        >>> print(output)
-        [1 3]
-    """
-    return masked_select_(input, mask)
-
-
-def masked_fill(input_x, mask, value):
-    """
-    Fills elements of Tensor with value where mask is True.
-    The shapes of `input_x` and `mask` need to be the same or broadcastable.
-
-    Args:
-        input_x (Tensor): The source Tensor whose data type is one of bool, uint8, int8, int16, int32,
-                    int64, float16, float32, float64, complex64, complex128.
-        mask (Tensor[bool]): The boolean mask.
-        value (Union[float, Tensor]): The value to fill in with, which dtype is the same as `input_x`.
-
-    Returns:
-        Tensor, has the same type and shape as `input_x`.
-
-    Raises:
-        TypeError: If dtype of `mask` is not bool.
-        TypeError: If `input_x` or `mask` is not a Tensor.
-        ValueError: If the shapes of `input_x` and `mask` could not be broadcast.
-        TypeError: If dtype of `input_x` or `value` is not one of bool, uint8, int8, int16, int32,
-                   int64, float16, float32, float64, complex64, complex128.
-        TypeError: If dtype of `value` is different from that of `input_x`.
-        TypeError: If `value` is neither float number nor Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
-        >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
-        >>> output = ops.masked_fill(input_x, mask, 0.5)
-        >>> print(output)
-        [0.5 0.5 3.  0.5]
-    """
-    if isinstance(value, (float, int)) and isinstance(input_x, Tensor):
-        value = scalar_to_tensor_(value, input_x.dtype)
-    masked_fill_ = _get_cache_prim(P.MaskedFill)()
-    return masked_fill_(input_x, mask, value)
-
-
-def diag(input):
-    r"""
-    Constructs a diagonal tensor with a given diagonal values.
-
-    Assume `input` has dimensions :math:`(D_1,... D_k)` , the output is a tensor of
-    rank 2k with dimensions :math:`(D_1,..., D_k, D_1,..., D_k)` where:
-    :math:`output[i_1,..., i_k, i_1,..., i_k] = input[i_1,..., i_k]` and 0 everywhere else.
+def masked_select(input, mask):
+    """
+    Returns a new 1-D Tensor which indexes the `x` tensor according to the boolean `mask`.
+    The shapes of the `mask` tensor and the `x` tensor don't need to match, but they must be broadcastable.
 
     Args:
-        input (Tensor): The input tensor.
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        mask (Tensor[bool]): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Returns:
-        Tensor, has the same dtype as the `input`.
+        A 1-D Tensor, with the same type as `input`.
 
     Raises:
-        TypeError: If `input` is not a Tensor.
-        ValueError: If rank of `input` is less than 1.
+        TypeError: If `input` or `mask` is not a Tensor.
+        TypeError: If dtype of `mask` is not bool.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
-        >>> input_x = Tensor([1, 2, 3, 4]).astype('int32')
-        >>> output = ops.diag(input_x)
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
+        >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
+        >>> output = ops.masked_select(x, mask)
         >>> print(output)
-        [[1 0 0 0]
-         [0 2 0 0]
-         [0 0 3 0]
-         [0 0 0 4]]
+        [1 3]
     """
-    return diag_(input)
+    return masked_select_(input, mask)
 
 
 def diagflat(input, offset=0):
@@ -5541,7 +4712,7 @@ def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
     Combines an array of sliding local blocks into a large containing tensor.
 
     Args:
-        input_x (Tensor): 4D tensor with data type float16 or float.
+        input_x (Tensor): 4D tensor with data type float16 or float32.
         output_size (Tensor): 1D tensor with 2 elements of data type int.
         kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
             for height and width. If type is int, it means that height equal with width. Must be specified.
@@ -5597,7 +4768,7 @@ def _split_int(x, split_size_or_sections, axis):
         num_sections = length_along_dim // split_size_or_sections
         length1 = num_sections * split_size_or_sections
         length2 = length_along_dim - length1
-        start1 = _list_comprehensions(rank(x), 0, True)
+        start1 = _list_comprehensions(rank_(x), 0, True)
         size1 = _tuple_setitem(arr_shape, axis, length1)
         start2 = _tuple_setitem(start1, axis, length1)
         size2 = _tuple_setitem(arr_shape, axis, length2)
@@ -5627,7 +4798,6 @@ def _split_sub_tensors(x, split_size_or_sections, axis):
         sub_tensors.append(sliced_tensor)
     return sub_tensors
 
-
 def split(tensor, split_size_or_sections, axis=0):
     """
     Splits the Tensor into chunks along the given axis.
@@ -5649,9 +4819,9 @@ def split(tensor, split_size_or_sections, axis=0):
         TypeError: If argument `tensor` is not Tensor.
         TypeError: If argument `axis` is not Tensor.
         ValueError: If argument `axis` is out of range of :math:`[-tensor.ndim, tensor.ndim)` .
-        TypeError: If each element in 'split_size_or_sections' is not integer.
-        TypeError: If argument `indices_or_sections` is not int, tuple(int) or list(int).
-        ValueError: The sum of 'split_size_or_sections' is not equal to x.shape[axis].
+        TypeError: If each element in `split_size_or_sections` is not integer.
+        TypeError: If argument `split_size_or_sections` is not int, tuple(int) or list(int).
+        ValueError: The sum of `split_size_or_sections` is not equal to x.shape[axis].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5695,6 +4865,53 @@ def split(tensor, split_size_or_sections, axis=0):
                         f"but got {type(split_size_or_sections)}")
     return tuple(res)
 
+def split_ext(tensor, split_size_or_sections, axis=0):
+    """
+    Splits the Tensor into chunks along the given axis.
+
+    Args:
+        tensor (Tensor): A Tensor to be divided.
+        split_size_or_sections (Union[int, tuple(int), list(int)]):
+            If `split_size_or_sections` is an int type, `tensor` will be split into equally sized chunks,
+            each chunk with size `split_size_or_sections`. Last chunk will be smaller than `split_size_or_sections`
+            if `tensor.shape[axis]` is not divisible by `split_size_or_sections`.
+            If `split_size_or_sections` is a list type, then `tensor` will be split into len(split_size_or_sections)
+            chunks with sizes `split_size_or_sections` along the given `axis`.
+        axis (int): The axis along which to split. Default: ``0`` .
+
+    Returns:
+        A tuple of sub-tensors.
+
+    Raises:
+        TypeError: If argument `tensor` is not Tensor.
+        TypeError: If argument `axis` is not int.
+        ValueError: If argument `axis` is out of range of :[-tensor.ndim, tensor.ndim).
+        TypeError: If each element in `split_size_or_sections` is not integer.
+        TypeError: If argument `split_size_or_sections` is not int, tuple(int) or list(int).
+        ValueError: The sum of `split_size_or_sections` is not equal to x.shape[axis].
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import ops, Tensor
+        >>> input_x = np.arange(9).astype("float32")
+        >>> output = ops.split_ext(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Float32, value= [ 0.00000000e+00,  1.00000000e+00,  2.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    if isinstance(split_size_or_sections, int):
+        res = split_tensor(tensor, split_size_or_sections, axis)
+    elif isinstance(split_size_or_sections, (list, tuple)):
+        res = split_with_size(tensor, split_size_or_sections, axis)
+    else:
+        raise TypeError(f"Type of Argument `split_size_or_sections` should be integer, tuple(int) or list(int), " \
+                        f"but got {type(split_size_or_sections)}")
+    return res
+
 
 def tril(input, diagonal=0):  # pylint: disable=redefined-outer-name
     """
@@ -5757,67 +4974,6 @@ def tril(input, diagonal=0):  # pylint: disable=redefined-outer-name
     return tril_(input)
 
 
-def triu(input, diagonal=0):  # pylint: disable=redefined-outer-name
-    r"""
-    Returns the upper triangle part of 'input' (elements that contain the diagonal and below),
-    and set the other elements to zeros.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        input (Tensor): The input tensor with shape :math:`(M, N, *)` where * means any number of additional dimensions.
-        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
-            indicating the main diagonal.
-
-    Returns:
-        Tensor, a tensor has the same shape and data type as input.
-
-    Raises:
-        TypeError: If `diagonal` is not an int.
-        TypeError: If `input` is not a Tensor.
-        ValueError: If the dimension of `input` is less than 2.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
-        ...                      [ 5,  6,  7,  8],
-        ...                      [10, 11, 12, 13],
-        ...                      [14, 15, 16, 17]]))
-        >>> result = ops.triu(x)
-        >>> print(result)
-        [[ 1  2  3  4]
-         [ 0  6  7  8]
-         [ 0  0 12 13]
-         [ 0  0  0 17]]
-        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
-        ...                      [ 5,  6,  7,  8],
-        ...                      [10, 11, 12, 13],
-        ...                      [14, 15, 16, 17]]))
-        >>> result = ops.triu(x, diagonal=1)
-        >>> print(result)
-        [[ 0  2  3  4]
-         [ 0  0  7  8]
-         [ 0  0  0 13]
-         [ 0  0  0  0]]
-        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
-        ...                      [ 5,  6,  7,  8],
-        ...                      [10, 11, 12, 13],
-        ...                      [14, 15, 16, 17]]))
-        >>> result = ops.triu(x, diagonal=-1)
-        >>> print(result)
-        [[ 1  2  3  4]
-         [ 5  6  7  8]
-         [ 0 11 12 13]
-         [ 0  0 16 17]]
-    """
-    return _get_cache_prim(P.Triu)(diagonal)(input)
-
-
 @_primexpr
 def _canonicalize_axis(axis, ndim):
     """
@@ -5917,24 +5073,24 @@ def _tensor_split_sub_int(x, indices_or_sections, axis):
     arr_shape = x.shape
     length_along_dim = arr_shape[axis]
     if indices_or_sections > length_along_dim:
-        res = P.Split(axis, length_along_dim)(x)
+        res = _get_cache_prim(P.Split)(axis, length_along_dim)(x)
         indices_or_sections_n = [length_along_dim, length_along_dim + 1]
         res2 = _tensor_split_sub_tensors(x, indices_or_sections_n, axis)
         for _ in np.arange(length_along_dim, indices_or_sections):
             res += tuple(res2)[1:]
     elif length_along_dim % indices_or_sections == 0:
-        res = P.Split(axis, indices_or_sections)(x)
+        res = _get_cache_prim(P.Split)(axis, indices_or_sections)(x)
     else:
         num_long_tensor = length_along_dim % indices_or_sections
         num_short_tensor = indices_or_sections - num_long_tensor
         length1 = num_long_tensor * (length_along_dim // indices_or_sections + 1)
         length2 = length_along_dim - length1
-        start1 = _list_comprehensions(rank(x), 0, True)
+        start1 = _list_comprehensions(rank_(x), 0, True)
         size1 = _tuple_setitem(arr_shape, axis, length1)
         start2 = _tuple_setitem(start1, axis, length1)
         size2 = _tuple_setitem(arr_shape, axis, length2)
-        res = P.Split(axis, num_long_tensor)(tensor_slice(x, start1, size1)) + \
-              P.Split(axis, num_short_tensor)(tensor_slice(x, start2, size2))
+        res = _get_cache_prim(P.Split)(axis, num_long_tensor)(tensor_slice(x, start1, size1)) + \
+              _get_cache_prim(P.Split)(axis, num_short_tensor)(tensor_slice(x, start2, size2))
     return res
 
 
@@ -5948,11 +5104,11 @@ def tensor_split(input, indices_or_sections, axis=0):
 
             - If `indices_or_sections` is an integer n, input tensor will be split into n sections.
 
-              - If :math:`input.shape(axis)` can be divisible by n, sub-sections will have equal size
-                :math:`input.shape(axis) / n` .
-              - If :math:`input.shape(axis)` is not divisible by n, the first :math:`input.shape(axis) % n` sections
-                will have size :math:`input.shape(axis) // n + 1` , and the rest will have
-                size :math:`input.shape(axis) // n` .
+              - If :math:`input.shape[axis]` can be divisible by n, sub-sections will have equal size
+                :math:`input.shape[axis] / n` .
+              - If :math:`input.shape[axis]` is not divisible by n, the first :math:`input.shape[axis] \bmod n` sections
+                will have size :math:`input.shape[axis] // n + 1` , and the rest will have
+                size :math:`input.shape[axis] // n` .
             - If `indices_or_sections` is of type tuple(int) or list(int), the input tensor will be split at the
               indices in the list or tuple. For example, given parameters :math:`indices\_or\_sections=[1, 4]`
               and :math:`axis=0` , the input tensor will be split into sections :math:`input[:1]` ,
@@ -6165,7 +5321,7 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         tensor.
 
         - values (Tensor) - The maximum value of input tensor, with the same shape as index, and same dtype as x.
-        - index (Tensor) - The index for the maximum value of the input tensor, with dtype int32. If `keepdims`
+        - index (Tensor) - The index for the maximum value of the input tensor, with dtype int64. If `keepdims`
           is true, the shape of output tensors is :math:`(input_1, input_2, ..., input_{axis-1}, 1, input_{axis+1},
           ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ..., input_{axis-1}, input_{axis+1},
           ..., input_N)` .
@@ -6194,16 +5350,15 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
     """
     if not input.shape:
-        return (input, Tensor(0, dtype=mstype.int32))
+        return (input, Tensor(0, dtype=mstype.int64))
     if axis is None:
-        reduce_max_op = _get_cache_prim(P.ReduceMax)()
-        return (reduce_max_op(input), Tensor(0, dtype=mstype.int32))
+        return (max_(input), Tensor(0, dtype=mstype.int64))
     if initial is not None and not isinstance(initial, numbers.Number):
         raise TypeError(f"For 'max', 'initial' must be a scalar, but got {type(initial)}")
     if axis is not None and not isinstance(axis, int):
         raise TypeError(f"For 'max', 'axis' must be int, but got {type(axis)}")
     input = _init_and_select_elem(input, initial, where, ops.maximum)
-    argmax_with_value_op = ArgMaxWithValue(axis, keepdims)
+    argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(axis, keepdims)
     indices, values = argmax_with_value_op(input)
     return values, indices
 
@@ -6249,10 +5404,11 @@ def argmax(input, dim=None, keepdim=False):
         is_dim_none = True
     out = _get_cache_prim(Argmax)(dim, mstype.int64)(input)
     if keepdim and not is_dim_none:
-        out = expand_dims_(out, dim)
+        out = expand_dims(out, dim)
     return out
 
 
+
 def min(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylint: disable=redefined-outer-name
     """
     Calculates the minimum value along with the given axis for the input tensor. It returns the minimum values and
@@ -6311,16 +5467,16 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         0.0 0
     """
     if not input.shape:
-        return (input, Tensor(0, dtype=mstype.int32))
+        return (input, Tensor(0, dtype=mstype.int64))
     if axis is None:
-        return (reduce_min(input), Tensor(0, dtype=mstype.int32))
+        return (min_(input), Tensor(0, dtype=mstype.int64))
     if initial is not None and not isinstance(initial, numbers.Number):
         raise TypeError(f"For 'min', 'initial' must be a scalar, but got {type(initial)}")
     if axis is not None and not isinstance(axis, int):
         raise TypeError(f"For 'min', 'axis' must be int, but got {type(axis)}")
     input = _init_and_select_elem(input, initial, where, ops.minimum)
-    argmin_with_value_ = ArgMinWithValue(axis=axis, keep_dims=keepdims)
-    indices, values = argmin_with_value_(input)
+    argmin_with_value_op = _get_cache_prim(ArgMinWithValue)(axis, keepdims)
+    indices, values = argmin_with_value_op(input)
     return values, indices
 
 
@@ -6378,8 +5534,8 @@ def aminmax(input, *, axis=0, keepdims=False):
             output0 = ops.reshape(output0, [1] * input.ndim)
             output1 = ops.reshape(output1, [1] * input.ndim)
         return output0, output1
-    argmin_with_value_op = P.ArgMinWithValue(axis, keepdims)
-    argmax_with_value_op = P.ArgMaxWithValue(axis, keepdims)
+    argmin_with_value_op = _get_cache_prim(ArgMinWithValue)(axis, keepdims)
+    argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(axis, keepdims)
     _, output0 = argmin_with_value_op(input)
     _, output1 = argmax_with_value_op(input)
     if keepdims is True and input.ndim == 0:
@@ -6434,66 +5590,48 @@ def narrow(input, axis, start, length):
     begins[axis] = start
     sizes = list(input.shape)
     sizes[axis] = length
-    return P.Slice()(input, begins, sizes)
-
-
-def unsorted_segment_sum(input_x, segment_ids, num_segments):
-    r"""
-    Computes the sum of a tensor along segments.
+    return tensor_slice(input, begins, sizes)
 
-    Calculates a tensor such that :math:`\text{output}[i] = \sum_{segment\_ids[j] == i} \text{data}[j, \ldots]`, where
-    :math:`j,...` is a tuple describing the index of element in data.
-    `segment_ids` selects which elements in data to sum
-    up. Segment_ids does not need to be sorted, and it does not need to cover all values in the entire valid value
-    range.
 
-    The following figure shows the calculation process of unsorted_segment_sum:
-
-    .. image:: UnsortedSegmentSum.png
-
-    Note:
-        - If the segment_id i is absent in the segment_ids, then output[i] will be filled with 0.
-        - On Ascend, if the value of segment_id is less than 0 or greater than the length of the input data shape, an
-          execution error will occur.
-
-    If the sum of the given segment_ids :math:`i` is empty, then :math:`\text{output}[i] = 0`. If the given segment_ids
-    is negative, the value will be ignored. 'num_segments' must be equal to the number of different segment_ids.
+def narrow_ext(input, dim, start, length):
+    """
+    Returns a narrowed tensor from input tensor, and
+    the dimension axis is input from start to start + length.
 
     Args:
-        input_x (Tensor): Input Tensor contains the data to be summed.
-          The shape is :math:`(x_1, x_2, ..., x_R)`.
-        segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
-            Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
-        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
+        input (Tensor): the tensor to narrow.
+        dim (int): dimension  along which to narrow.
+        start (int): the starting dimension.
+        length (int): the distance to the ending dimension.
 
     Returns:
-        Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
+        Tensor.
 
     Raises:
-        TypeError: If `num_segments` is not an int or 0-D Tensor.
-        ValueError: If length of shape of `segment_ids` is less than 1.
+        ValueError: If dim is out of range [-input.ndim, input.ndim).
+        ValueError: If start is out of range [-input.shape[dim], input.shape[dim]].
+        ValueError: It length is out of range [0, input.shape[dim]-start].
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> from mindspore import Tensor
-        >>> from mindspore import ops
         >>> import mindspore
-        >>> input_x = Tensor([1, 2, 3, 4], mindspore.float32)
-        >>> segment_ids = Tensor([0, 0, 1, 2], mindspore.int32)
-        >>> num_segments = 4
-        >>> output = ops.unsorted_segment_sum(input_x, segment_ids, num_segments)
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mindspore.int32)
+        >>> output = ops.narrow(x, 0, 0, 2)
         >>> print(output)
-        [3. 3. 4. 0.]
-        >>> input_x = Tensor([1, 2, 3, 4, 2, 5], mindspore.float32)
-        >>> segment_ids = Tensor([0, 0, 1, 2, 3, 4], mindspore.int32)
-        >>> num_segments = 6
-        >>> output = ops.unsorted_segment_sum(input_x, segment_ids, num_segments)
+        [[ 1 2 3]
+         [ 4 5 6]]
+        >>> output = ops.narrow(x, 1, 1, 2)
         >>> print(output)
-        [3. 3. 4. 2. 5. 0.]
+        [[ 2 3]
+         [ 5 6]
+         [ 8 9]]
     """
-    return unsorted_segment_sum_(input_x, segment_ids, num_segments)
+    validator.check_value_type("input", input, Tensor, "narrow")
+    return slice_ext_op(input, dim, start, start+length, 1)
 
 
 def topk(input, k, dim=None, largest=True, sorted=True):
@@ -6520,7 +5658,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
     Args:
         input (Tensor): Input to be computed, data type must be float16, float32 or int32.
-        k (int): The number of top or bottom elements to be computed along the last dimension, constant input is needed.
+        k (int): The number of top or bottom elements to be computed along the last dimension.
         dim (int, optional): The dimension to sort along. Default: ``None`` .
         largest (bool, optional): If largest is ``False``  then the k smallest elements are returned.
             Default: ``True`` .
@@ -6650,8 +5788,8 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
         A Tensor, with same type as `input` . And its shape is as described above.
 
     Raises:
-        TypeError: If `kernel_size`, `dilation`, `padding`, `stride` data type is not int, tuple or list.
-        ValueError: If `kernel_size`, `dilation`, `stride` value is not
+        TypeError: If `output_size`, `kernel_size`, `stride`, `dilation`, `padding` data type is not int, tuple or list.
+        ValueError: If `output_size`, `kernel_size`, `dilation`, `stride` value is not
             greater than zero or elements number more than `2`.
         ValueError: If `padding` value is less than zero or elements number more than `2`.
         ValueError: If `input.shape[1] != kernel_size[0] * kernel_size[1]`
@@ -6727,9 +5865,7 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     .. warning::
         - The output is a 3-dimensional Tensor whose shape is
           :math:`(N, C \times \prod(\text{kernel_size}), L)` .
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
+        - This is an experimental API that is subject to change or deletion.
 
     Args:
         input (Tensor): 4-D Tensor, supported dtypes: float16, float32, float64, complex64 and complex128.
@@ -6738,10 +5874,11 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
         dilation (Union[int, tuple[int], list[int]], optional): The dilation of the window, should be two int
             for height and width. If type is int, it means that height equal with width. Default: ``1`` .
         padding (Union[int, tuple[int], list[int]], optional): The pad of the window, that must be
-            a tuple/list of one or two `int` for height and width.
-            If one int, pad_height = pad_width.
-            If two int, pad_height = padding[0], pad_width = padding[1].
-            Default: ``0`` .
+            a tuple/list of one or two `int` for height and width. Default: ``0`` .
+
+            - If one int, pad_height = pad_width.
+            - If two int, pad_height = padding[0], pad_width = padding[1].
+
         stride (Union[int, tuple[int], list[int]], optional): The stride of the window, should be two int
             for height and width. If type is int, it means that height equal with width. Default: ``1`` .
 
@@ -6788,98 +5925,6 @@ def _check_diagonal_axes(dim1, dim2, x_ndim):
     return axes
 
 
-def diagonal(input, offset=0, dim1=0, dim2=1):
-    """
-    Returns specified diagonals of `input`.
-
-    If `input` is 2-D, returns the diagonal of `input` with the given offset.
-    If `input` has more than two
-    dimensions, then the axes specified by `dim1` and `dim2` are used to determine
-    the 2-D sub-array whose diagonal is returned. In this case, remove the `dim1` and `dim2` dimensions of `input`
-    and insert the last dimension of `input` by the diagonal elements determined by `dim1` and `dim2`.
-
-    Args:
-        input (Tensor): Array from which the diagonals are taken.
-        offset (int, optional): Offset of the diagonal from the main diagonal.
-            Can be positive or negative. Default: ``0`` .
-        dim1 (int, optional): Axis to be used as the first axis of the 2-D
-            sub-arrays from which the diagonals should be taken. Defaults to
-            first axis (0). Default: ``0`` .
-        dim2 (int, optional): Axis to be used as the second axis of the 2-D
-            sub-arrays from which the diagonals should be taken. Defaults to
-            second axis (1). Default: ``1`` .
-
-    Returns:
-        Tensor, if `input` is 2-D, then `input` 1-D array containing the diagonal. If
-        ``input.ndim > 2``, then the dimensions specified by `dim1` and `dim2` are removed,
-        and a new axis inserted at the end corresponding to the diagonal.
-
-    Raises:
-        TypeError: if `dim1` or `dim2` are not an int.
-        ValueError: if the input tensor has less than two dimensions.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> x = Tensor([[0, 1], [2, 3]], mstype.float32)
-        >>> output = ops.diagonal(x)
-        >>> print(output)
-        [0 3]
-    """
-    x_ndim = input.ndim
-    if x_ndim < 2:
-        raise ValueError(f"For 'ops.diagonal', the original tensor requires at least two dimensions, but got {x_ndim}")
-    _check_attr_dtype("dim1", dim1, [int], "diagonal")
-    _check_attr_dtype("dim2", dim2, [int], "diagonal")
-    dtype = input.dtype
-
-    axes = _check_diagonal_axes(dim1, dim2, x_ndim)
-    perm = ()
-    for i in ms_arrange(x_ndim):
-        if i not in axes:
-            perm += (i,)
-    perm += axes
-    input = input.transpose(perm)
-
-    x_shape = input.shape
-    n, m = x_shape[-2:]
-
-    e = ops.eye(n, m, dtype)
-    if offset >= m or offset <= -n:
-        zero_shape = x_shape[:-2] + (0,)
-        return ops.zeros(zero_shape, dtype)
-    if offset != 0:
-        e = e.astype(mstype.float32)
-        if offset > 0:
-            e_left = ops.fill(mstype.float32, (n, offset), 0)
-            e_right = e[..., 0:m - offset:1]
-            e = ops.cat((e_left, e_right), 1).astype(dtype)
-        elif offset < 0:
-            e_upper = ops.fill(mstype.float32, (-offset, m), 0)
-            e_lower = e[0:n + offset:1, ...]
-            e = ops.cat((e_upper, e_lower), 0).astype(dtype)
-    e = ops.broadcast_to(e, x_shape)
-
-    prod_val = ops.mul(input, e)
-    res = ops.ReduceSum()(prod_val.astype(mstype.float32), -1)
-
-    begin = ()
-    for _ in ms_arrange(x_ndim - 2):
-        begin += (0,)
-    last_dim_begin = builtins.max(0, -offset)
-    begin += (last_dim_begin,)
-    res_size = res.shape[:-1]
-    last_dim_end = builtins.min(x_shape[-2], builtins.max(0, x_shape[-1] - offset)) - last_dim_begin
-    if last_dim_end <= 0:
-        return Tensor([])
-    res_size += (last_dim_end,)
-    res = ops.slice(res, begin, res_size)
-    return res.astype(dtype)
-
-
 def _check_is_tensor(param_name, input, cls_name):
     """Returns True if input is Tensor."""
     if not isinstance(input, Tensor):
@@ -6899,6 +5944,9 @@ def diagonal_scatter(input, src, offset=0, dim1=0, dim2=1):
     the elements in these two dimensions will be treated as elements of a matrix,
     and `src` is embedded on the diagonal of the matrix.
 
+    Note:
+        Currently, ``inf`` value of elements in `input` or `src` is not supported.
+
     Args:
         input (Tensor): Input Tensor, whose dimension is larger than 1.
         src (Tensor): The source Tensor to embed.
@@ -6935,16 +5983,39 @@ def diagonal_scatter(input, src, offset=0, dim1=0, dim2=1):
     """
     _check_is_tensor("input", input, "diagonal_scatter")
     _check_is_tensor("src", src, "diagonal_scatter")
-    _check_is_int(offset, "offset", "diagonal_scatter")
-    _check_is_int(dim1, "dim1", "diagonal_scatter")
-    _check_is_int(dim2, "dim2", "diagonal_scatter")
     input_diag = input.diagonal(offset, dim1, dim2)
     _check_diagonal_scatter_shape(input_diag.shape, src.shape)
-    embed = ones_like(src)
-    embed = ops.diag_embed(embed, offset, dim1, dim2)
-    embed = input * embed
+    input_shape = input.shape
+    zeros_shape = list(input_shape)
+    m, n = input_shape[dim1], input_shape[dim2]
+    if m == n:
+        src = src - input_diag
+        src = ops.diag_embed(src, offset, dim1, dim2)
+        return input + src
+    if m > n:
+        axis = dim2
+        zeros_shape[axis] = m - n
+    else:
+        axis = dim1
+        zeros_shape[axis] = n - m
+    zeros_tensor = zeros(zeros_shape, dtype=input.dtype)
+    input = concat((input, zeros_tensor), axis)
+    input_diag = input.diagonal(offset, dim1, dim2)
+    if src.shape != input_diag.shape:
+        zeros_shape = []
+        for i, ax in enumerate(src.shape):
+            if ax == input_diag.shape[i]:
+                zeros_shape.append(ax)
+            else:
+                axis = i
+                zeros_shape.append(input_diag.shape[i] - ax)
+        zeros_tensor = zeros(zeros_shape, dtype=src.dtype)
+        src = concat((src, zeros_tensor), axis)
+    src = src - input_diag
     src = ops.diag_embed(src, offset, dim1, dim2)
-    return input + src - embed
+    input = input + src
+    begin = (0,) * input.ndim
+    return slice(input, begin, input_shape)
 
 
 def lstsq(input, A):
@@ -7003,8 +6074,7 @@ def lstsq(input, A):
          [-6.5000005 -4.500001 ]
          [-3.500002  -2.5000017]]
     """
-    lstsq_op = _get_cache_prim(Lstsq)()
-    return lstsq_op(input, A)
+    return lstsq_(input, A)
 
 
 def mvlgamma(input, p):
@@ -7052,6 +6122,64 @@ def mvlgamma(input, p):
     return mvlgamma_op(input)
 
 
+def nonzero(input, as_tuple=False):
+    r"""
+    Return the positions of all non-zero values.
+
+    Args:
+        input (Tensor): The input Tensor, its rank should be greater than or equal to 1.
+        as_tuple (bool, optional): Whether the output is tuple.
+            If ``False`` , return Tensor. Default: ``False`` .
+            If ``True`` , return Tuple of Tensor, only support ``Ascend`` .
+
+
+    Returns:
+        - If `as_tuple` is ``False``, return the Tensor, a 2-D Tensor whose data type is int64,
+          containing the positions of all non-zero values of the input.
+        - If `as_tuple` is ``True``, return the Tuple of Tensor and data type is int64.
+          The Tuple length is the dimension of the input tensor,
+          and each element is the 1D tensor of the subscript of all non-zero elements of
+          the input tensor in that dimension.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        TypeError: If `as_tuple` is not bool.
+        ValueError: If dim of `input` equals to 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+        >>> output = ops.nonzero(x)
+        >>> print(output)
+        [[0 0 0]
+         [0 1 0]]
+        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+        >>> output = ops.nonzero(x, False)
+        >>> print(output)
+        [[0]
+         [2]
+         [4]]
+        >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+        >>> output = ops.nonzero(x, True)
+        >>> print(output)
+        (Tensor(shape=[2], dtype=Int64, value=[0, 0]),
+         Tensor(shape=[2], dtype=Int64, value=[0, 1]),
+         Tensor(shape=[2], dtype=Int64, value=[0, 0]))
+        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+        >>> output = ops.nonzero(x, True)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Int64, value=[0, 2, 4]), )
+    """
+    if as_tuple:
+        return non_zero_ext_(input)
+    return non_zero_(input)
+
+
 def argwhere(input):
     """
     Return a Tensor of the positions of all non-zero values.
@@ -7079,7 +6207,7 @@ def argwhere(input):
         [[0 0 0]
          [0 1 0]]
     """
-    return nonzero_(input)
+    return nonzero(input)
 
 
 def column_stack(tensors):
@@ -7116,14 +6244,13 @@ def column_stack(tensors):
         raise TypeError(f"For column_stack, the input must be list or tuple of tensors, but got {type(tensors)}.")
 
     trans_x = ()
-    _expand_dims = _get_cache_prim(P.ExpandDims)()
     for tensor in tensors:
         if not isinstance(tensor, Tensor):
             raise TypeError(f"For column_stack, the input element must be tensor, but got {type(tensor)}.")
         if tensor.ndim < 1:
-            tensor = _expand_dims(tensor, 0)
+            tensor = expand_dims(tensor, 0)
         if tensor.ndim == 1:
-            tensor = _expand_dims(tensor, 1)
+            tensor = expand_dims(tensor, 1)
         trans_x += (tensor,)
     if not trans_x:
         raise ValueError(f"For column_stack, the input must have at least 1 tensor, but got 0.")
@@ -7169,7 +6296,7 @@ def hstack(tensors):
         if not isinstance(tensor, Tensor):
             raise TypeError(f"For hstack, the input element must be tensor, but got {type(tensor)}.")
         if tensor.ndim < 1:
-            tensor = expand_dims_(tensor, 0)
+            tensor = expand_dims(tensor, 0)
         tuple_of_tensor += (tensor,)
     if not tuple_of_tensor:
         raise ValueError("For hstack, the input must have at least 1 tensor, but got 0.")
@@ -7269,7 +6396,7 @@ def movedim(x, source, destination):
             f"For `source` and `destination` arguments, the number of elements must be the same, but got 'source':"
             f" {len(source)} and 'destination': {len(destination)}.")
     perm = _get_moved_perm(ndim, source, destination)
-    return _get_cache_prim(P.Transpose)()(x, perm)
+    return transpose_(x, perm)
 
 
 def moveaxis(x, source, destination):
@@ -7320,7 +6447,7 @@ def swapaxes(input, axis0, axis1):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapaxes(input, 0, 2)
@@ -7344,7 +6471,7 @@ def swapaxes(input, axis0, axis1):
         new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
                    perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1]
 
-    return _get_cache_prim(P.Transpose)()(input, new_perm)
+    return transpose_(input, new_perm)
 
 
 def swapdims(input, dim0, dim1):
@@ -7370,7 +6497,7 @@ def swapdims(input, dim0, dim1):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapdims(input, 0, 2)
@@ -7452,9 +6579,47 @@ def repeat_interleave(input, repeats, axis=None):
     return output
 
 
+def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
+    r"""
+    Repeat elements of a tensor along an axis, like `numpy.repeat`.
+
+    Args:
+        input (Tensor): The tensor to repeat values for. Must be of type: float16,
+            float32, int8, uint8, int16, int32, or int64.
+        repeats (Union[int, tuple, list, Tensor]): The number of times to repeat, must be positive.
+        dim (int, optional): The dim along which to repeat, Default: ``None``. if dims is None,
+            the input Tensor will be flattened and the output will alse be flattened.
+        output_size (int, optional): Total output size for the given axis (e.g. sum of repeats),
+            Default: ``None``.
+
+    Returns:
+        One tensor with values repeated along the specified dim. If input has shape
+        :math:`(s1, s2, ..., sn)` and dim is i, the output will have shape :math:`(s1, s2, ...,
+        si * repeats, ..., sn)`. The output type will be the same as the type of `input`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
+        >>> output = ops.function.array_func.repeat_interleave_ext(input, repeats=2, dim=0)
+        >>> print(output)
+        [[0 1 2]
+         [0 1 2]
+         [3 4 5]
+         [3 4 5]]
+    """
+    if isinstance(repeats, int):
+        return repeat_interleave_int_(input, repeats, dim, output_size)
+    return repeat_interleave_tensor_(input, repeats, dim, output_size)
+
+
 def repeat_elements(x, rep, axis=0):
     """
-    Repeat elements of a tensor along an axis, like `np.repeat` .
+    Repeat elements of a tensor along an axis, like `numpy.repeat` .
 
     Args:
         x (Tensor): The tensor to repeat values for. Must be of type: float16,
@@ -7492,34 +6657,19 @@ def repeat_elements(x, rep, axis=0):
     const_utils.check_type_valid(ops.dtype(x), mstype.number_type, 'input x')
     rep = _check_positive_int(rep, "rep", "repeat_elements")
     axis = _check_is_int(axis, "axis", "repeat_elements")
-    shape_op = P.Shape()
-    rank_op = P.Rank()
-    tile_op = P.Tile()
-    expand_dims_op = P.ExpandDims()
-    reshape_op = P.Reshape()
-    x_rank = rank_op(x)
+    x_rank = rank_(x)
     axis = _check_axis_range(axis, x_rank, "axis", "repeat_elements")
+    axis = axis + x.ndim if axis < 0 else axis
     expand_axis = axis + 1
-    x_expand = expand_dims_op(x, expand_axis)
+    x_expand = expand_dims(x, expand_axis)
     rep_dims = _cal_repeat_dims(x_rank, rep, expand_axis)
-    x_expand = tile_op(x_expand, rep_dims)
-    x_shape = shape_op(x)
+    x_expand = tile_(x_expand, rep_dims)
+    x_shape = shape_(x)
     x_reshape = _cal_reshape(x_shape, rep, axis)
-    x_rep = reshape_op(x_expand, x_reshape)
+    x_rep = reshape_(x_expand, x_reshape)
     return x_rep
 
 
-@_primexpr
-def _check_sequence_mask_input_len(input_shape, prim_name=None):
-    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-    if not input_shape:
-        raise ValueError(f"{msg_prefix} input_shape must be greater than 0, but got {input_shape}.")
-    # broadcast only supports 7d shape
-    shape_size = len(input_shape)
-    if shape_size >= 7:
-        raise ValueError(f"{msg_prefix} dimension of input_shape must be less than 7, but got {shape_size}d.")
-
-
 def sequence_mask(lengths, maxlen=None):
     """
     Returns a mask tensor representing the first N positions of each cell.
@@ -7572,29 +6722,19 @@ def sequence_mask(lengths, maxlen=None):
          [[ True  True False False ]
           [ True  True  True  True ]]]
     """
-
-    argmax_op = P.ArgMaxWithValue()
-    reshape_op = P.Reshape()
-    range_op = P.Range()
-    expand_op = P.ExpandDims()
-    cast_op = P.Cast()
-    to_tensor_op = P.ScalarToTensor()
-    shape_op = P.Shape()
-
     const_utils.check_type_valid(ops.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
-    _check_sequence_mask_input_len(shape_op(lengths), "sequence_mask")
 
     if maxlen is None:
-        flatten_data = reshape_op(lengths, (-1,))
-        flatten_data = cast_op(flatten_data, mstype.float32)
-        _, value = argmax_op(flatten_data)
-        maxlen = cast_op(value, mstype.int32)
+        flatten_data = reshape_(lengths, (-1,))
+        flatten_data = cast_(flatten_data, mstype.float32)
+        _, value = arg_max_with_value_(flatten_data)
+        maxlen = cast_(value, mstype.int32)
     else:
         maxlen = _check_positive_int(maxlen, "maxlen", "sequence_mask")
-        maxlen = to_tensor_op(maxlen, mstype.int32)
+        maxlen = scalar_to_tensor_(maxlen, mstype.int32)
 
-    range_vector = range_op(to_tensor_op(0, mstype.int32), maxlen, to_tensor_op(1, mstype.int32))
-    mask = expand_op(lengths, -1)
+    range_vector = range_(scalar_to_tensor_(0, mstype.int32), maxlen, scalar_to_tensor_(1, mstype.int32))
+    mask = expand_dims(lengths, -1)
     result = range_vector < mask
     return result
 
@@ -7607,35 +6747,6 @@ def top_k(input_x, k, sorted=True):
     return top_k_(input_x, k)
 
 
-def deepcopy(input_x):
-    """
-    Returns a deepcopy of input tensor.
-
-    Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-    Returns:
-        Tensor, a deepcopy of `input_x`.
-
-    Raises:
-        TypeError: If `input_x` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
-        >>> output = ops.deepcopy(input)
-        >>> print(output)
-        [[0 1]
-         [2 1]]
-    """
-    _deepcopy = _get_cache_prim(P.Identity)()
-    return _deepcopy(input_x)
-
-
 __all__ = [
     'unique',
     'unique_with_pad',
@@ -7662,8 +6773,8 @@ __all__ = [
     'full_like',
     'dyn_shape',
     'rank',
-    'range',
     'arange',
+    'range',
     'reshape',
     'reshape_',
     'flatten',
@@ -7772,6 +6883,7 @@ __all__ = [
     'aminmax',
     'sort',
     'top_k',
-    'deepcopy'
+    'deepcopy',
+    'flip',
 ]
 __all__.sort()