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

mindspore/ops/function/array_func.py

@@ -32,14 +32,13 @@ 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 import OnesLikeExt, ZerosLikeExt, FillScalar, FillTensor, Arange, Chunk, UniqueDim, \
+    Unique2, SortExt, NonZero, NonZeroExt, Scatter, ScatterValue
 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.auto_generate.pyboost_inner_prim import _PyboostSearchSortedPrim
 from mindspore.ops.operations.array_ops import (
     UniqueConsecutive,
-    SearchSorted,
     MatrixDiagV3,
     MatrixDiagPartV3,
     MatrixSetDiagV3,
@@ -58,7 +57,6 @@ from mindspore.ops.operations.array_ops import (
     ArgMaxWithValue,
     ArgMinWithValue
 )
-from mindspore.ops.operations.array_ops import TensorScatterElements
 from mindspore.common import Tensor
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as validator
@@ -66,10 +64,12 @@ from mindspore._c_expression import Tensor as Tensor_
 from mindspore.ops._utils.utils import ms_arrange
 
 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
+    flip, transpose, triu, unsorted_segment_sum, diag, gather, gather_d, gather_nd, reshape, masked_select, \
+    broadcast_to, strided_slice, ones, zeros, max_, min_, select, zero_
+from mindspore.ops.auto_generate import tensor_scatter_elements as tensor_scatter_elements_ext
+from mindspore.ops.auto_generate.gen_ops_prim import scatter_add_ext_op, slice_ext_op, gather_d_op
 from mindspore.ops.operations.manually_defined import tile, rank, scalar_cast
+from mindspore.ops.auto_generate.pyboost_inner_prim import _PyboostOneHotExtPrim, tril_ext_impl
 
 arg_max_with_value_ = ArgMaxWithValue()
 arg_min_with_value_ = ArgMinWithValue()
@@ -87,7 +87,6 @@ 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()
 population_count_ = P.PopulationCount()
@@ -104,6 +103,7 @@ scatter_min_ = P.ScatterMin()
 scatter_mul_ = P.ScatterMul()
 scatter_nd_ = P.ScatterNd()
 scatter_update_ = P.ScatterUpdate()
+search_sorted_ = _PyboostSearchSortedPrim()
 shape_ = P.Shape()
 split_tensor = SplitTensor()
 split_with_size = SplitWithSize()
@@ -122,18 +122,20 @@ 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()
 ones_like_ = P.OnesLike()
+one_hot_ext_impl = _PyboostOneHotExtPrim()
 zeros_like_ = P.ZerosLike()
 ones_like_ext_ = OnesLikeExt()
 zeros_like_ext_ = ZerosLikeExt()
 fill_scalar_ = FillScalar()
 fill_tensor_ = FillTensor()
 sort_ext_ = SortExt()
+scatter_ = Scatter()
+scatter_value_ = ScatterValue()
 arange_ = Arange()
 chunk_ = Chunk()
 repeat_interleave_int_ = RepeatInterleaveInt()
@@ -199,7 +201,8 @@ def _get_max_type(start, end, step):
 
     type_map = {'Float64': '3', 'Float32': '2', "<class 'float'>": '2', 'Int64': '1', "<class 'int'>": '1',
                 'Int32': '0'}
-    type_map_reverse = {'3': mstype.float64, '2': mstype.float32, '1': mstype.int64, '0': mstype.int32}
+    type_map_reverse = {'3': mstype.float64,
+                        '2': mstype.float32, '1': mstype.int64, '0': mstype.int32}
     type_level = [type_map.get(i) for i in arg_type_map]
     max_level = builtins.max(type_level)
     return type_map_reverse.get(max_level)
@@ -329,7 +332,7 @@ def arange_ext(start=0, end=None, step=1, *, dtype=None):
         [7 5 3]
         >>> print(output.dtype)
         Int64
-        >>> output = ops.arange_ext(12, 2, -1, dtype=ms.bfloat16))
+        >>> 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)
@@ -347,9 +350,9 @@ def concat(tensors, axis=0):
     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>`_
+          <https://mindspore.cn/tutorials/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>`_
+          <https://mindspore.cn/tutorials/en/master/nlp/sentiment_analysis.html#dense>`_
     """
     return cat(tensors, axis)
 
@@ -451,20 +454,25 @@ def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype
         [0.08 0.39785218 0.91214782  0.91214782  0.39785218 0.08]
     """
     if not isinstance(window_length, int):
-        raise TypeError(f"For array function 'hamming_window', 'window_length' must be int, but got" \
+        raise TypeError(f"For array function 'hamming_window', 'window_length' must be int, but got"
                         f" {type(window_length)}.")
     if window_length < 0:
-        raise ValueError(f"For array function 'hamming_window', 'window_length' must be non negative number.")
+        raise ValueError(
+            f"For array function 'hamming_window', 'window_length' must be non negative number.")
     if not isinstance(periodic, bool):
-        raise TypeError(f"For array function 'hamming_window', 'periodic' must be bool, but got {type(periodic)}.")
+        raise TypeError(
+            f"For array function 'hamming_window', 'periodic' must be bool, but got {type(periodic)}.")
     if not isinstance(alpha, float):
-        raise TypeError(f"For array function 'hamming_window', 'alpha' must be float, but got {type(alpha)}.")
+        raise TypeError(
+            f"For array function 'hamming_window', 'alpha' must be float, but got {type(alpha)}.")
     if not isinstance(beta, float):
-        raise TypeError(f"For array function 'hamming_window', 'beta' must be float, but got {type(beta)}.")
+        raise TypeError(
+            f"For array function 'hamming_window', 'beta' must be float, but got {type(beta)}.")
     if window_length <= 1:
         return Tensor(np.ones(window_length))
     if dtype is not None and dtype not in mstype.float_type:
-        raise TypeError(f"For array function 'hamming_window', 'dtype' must be floating point dtypes, but got {dtype}.")
+        raise TypeError(
+            f"For array function 'hamming_window', 'dtype' must be floating point dtypes, but got {dtype}.")
 
     dtype = mstype.float32 if dtype is None else dtype
     op = _get_cache_prim(P.HammingWindow)(periodic, alpha, beta, dtype)
@@ -641,7 +649,8 @@ def _check_axis_type(axis, type_int=True, type_tuple=True, type_list=True, ops_n
     if (type_tuple and isinstance(axis, tuple)) or (type_list and isinstance(axis, list)):
         for ax in axis:
             if not isinstance(ax, int):
-                raise TypeError(f"For {ops_name}, each axis must be integer, but got {type(ax)} in {axis}.")
+                raise TypeError(
+                    f"For {ops_name}, each axis must be integer, but got {type(ax)} in {axis}.")
         return True
 
     type_str = ""
@@ -651,7 +660,8 @@ def _check_axis_type(axis, type_int=True, type_tuple=True, type_list=True, ops_n
         type_str += "tuple, "
     if type_list:
         type_str += "list, "
-    raise TypeError(f"For {ops_name}, the axis should be {type_str}, but got {type(axis)}.")
+    raise TypeError(
+        f"For {ops_name}, the axis should be {type_str}, but got {type(axis)}.")
 
 
 def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
@@ -720,8 +730,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/master/api_python/mindspore.html#mindspore.dtype>`_ and
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ .
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ and
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ .
         shape (Union(Tensor, tuple[int])): The specified shape of output tensor.
         value (Union(Tensor, number.Number, bool)): Value to fill the returned tensor.
 
@@ -786,11 +796,13 @@ def full(size, fill_value, *, dtype=None):  # pylint: disable=redefined-outer-na
          [0. 0. 0.]]
     """
     if not isinstance(size, (list, tuple)):
-        raise TypeError(f"For 'ops.full', 'size' must be a tuple or list of ints, but got {type(size)}.")
+        raise TypeError(
+            f"For 'ops.full', 'size' must be a tuple or list of ints, but got {type(size)}.")
     if dtype is None:
         dtype = mstype.int64
     if dtype not in mstype.all_types:
-        raise TypeError(f"For 'ops.full', 'dtype' must be mindspore.type, but got {dtype}.")
+        raise TypeError(
+            f"For 'ops.full', 'dtype' must be mindspore.type, but got {dtype}.")
     if isinstance(size, list):
         size = tuple(size)
     return ops.fill(dtype, size, fill_value)
@@ -802,7 +814,8 @@ def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-oute
 
     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.
+        fill_value (Union(number.Number, Tensor)): Value to fill the returned tensor. It can be a Scalar number, a 0-D
+            Tensor, or a 1-D Tensor with only one element.
 
     Keyword Args:
         dtype (mindspore.dtype): The specified type of output tensor. `bool_` and `number` are supported, for details,
@@ -820,18 +833,16 @@ def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-oute
 
     Examples:
         >>> from mindspore import ops
-        >>> output = ops.full((2, 2), 1)
+        >>> output = ops.full_ext((2, 2), 1)
         >>> print(output)
         [[1. 1.]
          [1. 1.]]
-        >>> output = ops.full((3, 3), 0)
+        >>> output = ops.full_ext((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)
 
 
@@ -872,7 +883,8 @@ def full_like(input, fill_value, *, dtype=None):
          [0. 0. 0.]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f"For ops.full_like, the argument 'x' must be tensor, but got {type(input)}")
+        raise TypeError(
+            f"For ops.full_like, the argument 'x' must be tensor, but got {type(input)}")
     if dtype is None:
         dtype = input.dtype
     return full(input.shape, fill_value, dtype=dtype)
@@ -914,19 +926,24 @@ def chunk(input, chunks, axis=0):
          Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f'For ops.chunk parameter `input` must be Tensor, but got {type(input)}')
+        raise TypeError(
+            f'For ops.chunk parameter `input` must be Tensor, but got {type(input)}')
     _check_axis_type(axis, True, False, False, "ops.chunk")
     arr_axis = _canonicalize_axis(axis, input.ndim)
 
     if not isinstance(chunks, int):
-        raise TypeError(f"For ops.chunk type of argument `chunks` should be integer, but got {type(chunks)}")
+        raise TypeError(
+            f"For ops.chunk type of argument `chunks` should be integer, but got {type(chunks)}")
     if chunks <= 0:
-        raise ValueError(f"For ops.chunk parameter 'chunks' must be greater than 0, but got {chunks}")
+        raise ValueError(
+            f"For ops.chunk parameter 'chunks' must be greater than 0, but got {chunks}")
 
     arr_shape = input.shape
     length_along_dim = arr_shape[arr_axis]
 
-    if chunks > length_along_dim:
+    if length_along_dim == 0:
+        res = _get_cache_prim(P.Split)(arr_axis)(input)
+    elif chunks > length_along_dim:
         res = _get_cache_prim(P.Split)(arr_axis, length_along_dim)(input)
     elif length_along_dim % chunks == 0:
         res = _get_cache_prim(P.Split)(arr_axis, chunks)(input)
@@ -939,9 +956,11 @@ def chunk(input, chunks, axis=0):
         size1 = _tuple_setitem(arr_shape, arr_axis, length1)
         start2 = _tuple_setitem(start1, arr_axis, length1)
         size2 = _tuple_setitem(arr_shape, arr_axis, length2)
-        res = _get_cache_prim(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 += _get_cache_prim(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
 
 
@@ -952,6 +971,9 @@ def chunk_ext(input, chunks, dim=0):
     Note:
         This function may return less than the specified number of chunks!
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         input (Tensor): A Tensor to be cut.
         chunks (int): Number of sub-tensors to cut.
@@ -1260,11 +1282,14 @@ def unique_ext(input, sorted=True, return_inverse=False, return_counts=False, di
         [0 1 2 1]
     """
     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")
+        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)
+        y, inverse, counts = unique2_(
+            input, sorted, return_inverse, return_counts)
     else:
-        validator.check_value_type("return_counts", return_counts, [bool], "unique_ext")
+        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
@@ -1285,6 +1310,11 @@ def unique_with_pad(x, pad_num):
     the UniqueWithPad operator will fill the `y` Tensor with the `pad_num` specified by the user
     to make it have the same shape as the Tensor `idx`.
 
+    .. warning::
+        :func:`mindspore.ops.unique_with_pad` is deprecated from version 2.4 and will be removed in a future version.
+        Please use the :func:`mindspore.ops.unique` combined with :func:`mindspore.ops.pad` to realize
+        the same function.
+
     Args:
         x (Tensor): The tensor need to be unique. Must be 1-D vector with types: int32, int64.
         pad_num (int): Pad num. The data type is an int.
@@ -1297,10 +1327,10 @@ def unique_with_pad(x, pad_num):
 
     Raises:
         TypeError: If dtype of `x` is neither int32 nor int64.
-        ValueError: If length of shape of `x` is not equal to 1.
+        ValueError: If `x` is not a 1-D Tensor.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        Deprecated
 
     Examples:
         >>> import mindspore
@@ -1319,7 +1349,7 @@ def unique_with_pad(x, pad_num):
         >>> print(idx)
         [0 1 1 2 3 3]
     """
-    return unique_with_pad_(x, pad_num)
+    return _get_cache_prim(P.UniqueWithPad)()(x, pad_num)
 
 
 def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
@@ -1369,7 +1399,8 @@ def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
 
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For 'unique_consecutive', 'input' must be Tensor.")
-    unique_consecutive_op = _get_cache_prim(UniqueConsecutive)(return_idx, return_counts, axis)
+    unique_consecutive_op = _get_cache_prim(
+        UniqueConsecutive)(return_idx, return_counts, axis)
     output, idx, counts = unique_consecutive_op(input)
     if return_idx and return_counts:
         return output, idx, counts
@@ -1400,7 +1431,7 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=
             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`` .
+            dimension and type must be int64. Default: ``None`` . CPU and GPU can only use default values
 
     Returns:
         Tensor containing the indices from the innermost dimension of `sorted_sequence` such that,
@@ -1437,8 +1468,7 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=
                          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, sorter)
+    return search_sorted_(sorted_sequence, values, sorter, dtype, right)
 
 
 def ger(input, vec2):
@@ -1488,7 +1518,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/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -1681,7 +1711,8 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
 
     def check_dim_valid(start_dim, end_dim):
         if start_dim > end_dim:
-            raise ValueError("For 'flatten', 'start_dim' cannot come after 'end_dim'.")
+            raise ValueError(
+                "For 'flatten', 'start_dim' cannot come after 'end_dim'.")
 
     def canonicalize_axis(axis, x_rank):
         ndim = x_rank if x_rank != 0 else 1
@@ -1693,7 +1724,8 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
         raise TypeError(f"For 'flatten', argument 'input' must be Tensor.")
     if not isinstance(start_dim, int) or not isinstance(end_dim, int) or \
             isinstance(start_dim, bool) or isinstance(end_dim, bool):
-        raise TypeError(f"For 'flatten', both 'start_dim' and 'end_dim' must be int.")
+        raise TypeError(
+            f"For 'flatten', both 'start_dim' and 'end_dim' must be int.")
     check_flatten_order_const(order)
     if order == 'F':
         x_rank = rank_(input)
@@ -3269,13 +3301,13 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
     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`.
+        The backward is supported only for the case `updates.shape == indices.shape`.
 
     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
             mindspore.int64. Same rank as  `input_x`. And accepted range is [-s, s) where s is the size along axis.
-        updates (Tensor): The tensor doing the scatter operation with `input_x`, has the same type as `input_x` and
-            the same shape as `indices`.
+        updates (Tensor): The tensor doing the scatter operation with `input_x`.
         axis (int): Which axis to scatter. Accepted range is [-r, r) where r = rank(input_x). Default: ``0``.
         reduction (str): Which reduction operation to scatter, supports ``"none"`` , ``"add"`` . Default: ``"none"``.
             When `reduction` is set to ``"none"``, `updates` will be assigned to `input_x` according to  `indices`.
@@ -3287,7 +3319,6 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
     Raises:
         TypeError: If `indices` is neither int32 nor int64.
         ValueError: If anyone of the rank among `input_x`, `indices` and `updates` less than 1.
-        ValueError: If the shape of `updates` is not equal to the shape of `indices`.
         ValueError: If the rank of `updates` is not equal to the rank of `input_x`.
         RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
             is required when data type conversion of Parameter is not supported.
@@ -3319,8 +3350,7 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
          [ 5  5 14]
          [ 7 15 11]]
     """
-    _tensor_scatter_elements = _get_cache_prim(TensorScatterElements)(axis, reduction)
-    return _tensor_scatter_elements(input_x, indices, updates)
+    return tensor_scatter_elements_ext(input_x, indices, updates, axis, reduction)
 
 
 def scatter(input, axis, index, src):
@@ -3328,24 +3358,26 @@ def scatter(input, axis, index, src):
     Update the value in `src` to `input` according to the specified index.
     Refer to :func:`mindspore.ops.tensor_scatter_elements` for more details.
 
+    .. note::
+        The backward is supported only for the case `src.shape == index.shape`.
+
     Args:
         input (Tensor): The target tensor. The rank of `input` must be at least 1.
         axis (int): Which axis to scatter. Accepted range is [-r, r) where r = rank(input).
-        index (Tensor): The index to do update operation whose data type must be mindspore.int32 or
-            mindspore.int64. Same rank as `input` . And accepted range is [-s, s) where s is the size along axis.
-        src (Tensor): The tensor doing the update operation with `input` , has the same type as `input` ,
-            and the shape of `src` should be equal to the shape of `index` .
+        index (Tensor): The index to do update operation whose data must be positive number with type of mindspore.int32
+            or mindspore.int64. Same rank as `input` . And accepted range is [-s, s) where s is the size along axis.
+        src (Tensor, float): The data doing the update operation with `input`. Can be a tensor with the same data type
+            as `input` or a float number to scatter.
 
     Returns:
-        Tensor, has the same shape and type as `input` .
+        The backward is supported only for the case `src.shape == index.shape` when `src` is a tensor.
 
     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 shape of `src` is not equal to the shape of `index` .
+        ValueError: If rank of any of `input` , `index` and `src` less than 1.
         ValueError: If the rank of `src` is not equal to the rank of `input` .
-        RuntimeError: If the data type of `input` and `src` conversion of Parameter
-            is required when data type conversion of Parameter is not supported.
+        TypeError: If the data type of `input` and `src` have different dtypes.
+        RuntimeError: If `index` has negative elements.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3381,7 +3413,9 @@ def scatter(input, axis, index, src):
         [0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]]
     """
-    return ops.tensor_scatter_elements(input_x=input, indices=index, updates=src, axis=axis)
+    if isinstance(src, Tensor):
+        return scatter_(input, axis, index, src)
+    return scatter_value_(input, axis, index, src)
 
 
 def scatter_add_ext(input, dim, index, src):
@@ -3516,7 +3550,8 @@ def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
     _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)
+    input_rank, index, axis = _get_slice_scatter_const(
+        input_shape, axis, start, end, step)
 
     src_shape = src.shape
     index_shape = input_shape[:axis] + (len(index),) + input_shape[axis + 1:]
@@ -3638,7 +3673,8 @@ def space_to_batch_nd(input_x, block_size, paddings):
          [[[3.]]]
          [[[4.]]]]
     """
-    _space_to_batch_nd = _get_cache_prim(P.SpaceToBatchND)(block_size, paddings)
+    _space_to_batch_nd = _get_cache_prim(
+        P.SpaceToBatchND)(block_size, paddings)
     return _space_to_batch_nd(input_x)
 
 
@@ -4330,9 +4366,11 @@ def index_select(input, axis, index):
          [[ 8.  9. 10. 11.]]]
     """
     if not (isinstance(input, Tensor) and isinstance(index, Tensor)):
-        raise TypeError(f"For 'index_select', `input` and `index` must be all tensors.")
+        raise TypeError(
+            f"For 'index_select', `input` and `index` must be all tensors.")
     if index.ndim != 1:
-        raise ValueError(f"For 'index_select', the dimension of `index` must be 1, but got {index.ndim}")
+        raise ValueError(
+            f"For 'index_select', the dimension of `index` must be 1, but got {index.ndim}")
     axis = _check_check_axis_in_range(axis, input.ndim)
     return gather_(input, index, axis)
 
@@ -4425,9 +4463,11 @@ def is_nonzero(input):
         True
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f'For is_nonzero, the input must be a Tensor, but got {type(input)}.')
+        raise TypeError(
+            f'For is_nonzero, the input must be a Tensor, but got {type(input)}.')
     if input.numel() != 1:
-        raise ValueError(f"For is_nonzero, the numel of input must be 1, but got {input.numel()}.")
+        raise ValueError(
+            f"For is_nonzero, the numel of input must be 1, but got {input.numel()}.")
     out = ops.squeeze(input)
     return bool(out)
 
@@ -4622,38 +4662,6 @@ 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
-        >>> 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 3]
-    """
-    return masked_select_(input, mask)
-
-
 def diagflat(input, offset=0):
     r"""
     Create a 2-D Tensor which diagonal is the flattened `input` .
@@ -4687,9 +4695,11 @@ def diagflat(input, offset=0):
          [0. 0. 0.]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError(f"For diagflat, the input x must be tensor, but got {type(input)}")
+        raise TypeError(
+            f"For diagflat, the input x must be tensor, but got {type(input)}")
     if not isinstance(offset, int):
-        raise TypeError(f"For diagflat, the offset must be int, but got {type(offset)}")
+        raise TypeError(
+            f"For diagflat, the offset must be int, but got {type(offset)}")
     offset_abs = abs(offset)
     if input.size == 0:
         return zeros((offset_abs, offset_abs), input.dtype)
@@ -4759,7 +4769,9 @@ def _split_int(x, split_size_or_sections, axis):
     """
     arr_shape = x.shape
     length_along_dim = arr_shape[axis]
-    if split_size_or_sections > length_along_dim:
+    if length_along_dim == 0:
+        res = _get_cache_prim(P.Split)(axis)(x)
+    elif split_size_or_sections > length_along_dim:
         res = _get_cache_prim(P.Split)(axis, 1)(x)
     elif length_along_dim % split_size_or_sections == 0:
         sections = length_along_dim // split_size_or_sections
@@ -4773,7 +4785,7 @@ def _split_int(x, split_size_or_sections, axis):
         start2 = _tuple_setitem(start1, axis, length1)
         size2 = _tuple_setitem(arr_shape, axis, length2)
         res = _get_cache_prim(P.Split)(axis, num_sections)(tensor_slice(x, start1, size1)) + \
-              _get_cache_prim(P.Split)(axis, 1)(tensor_slice(x, start2, size2))
+            _get_cache_prim(P.Split)(axis, 1)(tensor_slice(x, start2, size2))
     return res
 
 
@@ -4798,6 +4810,7 @@ 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.
@@ -4839,7 +4852,8 @@ def split(tensor, split_size_or_sections, axis=0):
     if not isinstance(tensor, Tensor):
         raise TypeError(f'expect `tensor` is a Tensor, but got {type(tensor)}')
     if type(axis) is not int:
-        raise TypeError(f"Type of Argument `axis` should be integer but got {type(axis)}")
+        raise TypeError(
+            f"Type of Argument `axis` should be integer but got {type(axis)}")
     arr_axis = _canonicalize_axis(axis, tensor.ndim)
 
     if type(split_size_or_sections) is int:
@@ -4851,7 +4865,8 @@ def split(tensor, split_size_or_sections, axis=0):
     elif isinstance(split_size_or_sections, (list, tuple)):
         for item in split_size_or_sections:
             if type(item) is not int:
-                raise TypeError(f"Each element in 'split_size_or_sections' should be integer, but got {type(item)}.")
+                raise TypeError(
+                    f"Each element in 'split_size_or_sections' should be integer, but got {type(item)}.")
             if item < 0:
                 raise TypeError(f"Each element in 'split_size_or_sections' should be non-negative, "
                                 f"but got {split_size_or_sections}.")
@@ -4861,10 +4876,11 @@ def split(tensor, split_size_or_sections, axis=0):
                              f"but got {sum(split_size_or_sections)}.")
         res = _split_sub_tensors(tensor, split_size_or_sections, arr_axis)
     else:
-        raise TypeError(f"Type of Argument `split_size_or_sections` should be integer, tuple(int) or list(int), " \
+        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 tuple(res)
 
+
 def split_ext(tensor, split_size_or_sections, axis=0):
     """
     Splits the Tensor into chunks along the given axis.
@@ -4908,14 +4924,14 @@ def split_ext(tensor, split_size_or_sections, axis=0):
     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), " \
+        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
     """
-    Returns the lower triangle part of 'input' (elements that contain the diagonal and below),
+    Returns the lower triangle part of `input` (elements that contain the diagonal and below),
     and set the other elements to zeros.
 
     Args:
@@ -4925,13 +4941,13 @@ def tril(input, diagonal=0):  # pylint: disable=redefined-outer-name
             indicating the main diagonal.
 
     Returns:
-        Tensor, the same shape and data type as the input `x`.
+        Tensor, the same shape and data type as the `input`.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
         TypeError: If `diagonal` is not an int.
-        TypeError: If the type of `x` is neither number nor bool.
-        ValueError: If the rank of `x` is less than 2.
+        TypeError: If the type of `input` is neither number nor bool.
+        ValueError: If the rank of `input` is less than 2.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4970,10 +4986,70 @@ def tril(input, diagonal=0):  # pylint: disable=redefined-outer-name
          [10 11  0  0]
          [14 15 16  0]]
     """
-    tril_ = Tril(diagonal)
+    tril_ = _get_cache_prim(Tril)(diagonal)
     return tril_(input)
 
 
+def tril_ext(input, diagonal=0):
+    """
+    Returns the lower triangle part of `input` (elements that contain the diagonal and below),
+    and set the other elements to zeros.
+
+    Args:
+        input (Tensor): A Tensor with shape :math:`(x_1, x_2, ..., x_R)`. The rank must be at least 2.
+          Supporting all number types including bool.
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
+            indicating the main diagonal.
+
+    Returns:
+        Tensor, the same shape and data type as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `diagonal` is not an int.
+        TypeError: If the type of `input` is neither number nor bool.
+        ValueError: If the rank of `input` is less than 2.
+
+    Supported Platforms:
+        ``Ascend``
+
+    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.function.array_func.tril_ext(x)
+        >>> print(result)
+        [[ 1  0  0  0]
+         [ 5  6  0  0]
+         [10 11 12  0]
+         [14 15 16 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.function.array_func.tril_ext(x, diagonal=1)
+        >>> print(result)
+        [[ 1  2  0  0]
+         [ 5  6  7  0]
+         [10 11 12 13]
+         [14 15 16 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.function.array_func.tril_ext(x, diagonal=-1)
+        >>> print(result)
+        [[ 0  0  0  0]
+         [ 5  0  0  0]
+         [10 11  0  0]
+         [14 15 16  0]]
+    """
+    return tril_ext_impl(input, diagonal)
+
+
 @_primexpr
 def _canonicalize_axis(axis, ndim):
     """
@@ -4992,7 +5068,8 @@ def _canonicalize_axis(axis, ndim):
         if not isinstance(ax, int):
             raise TypeError(f'axis should be integers, not {type(ax)}')
         if not -ndim <= ax < ndim:
-            raise ValueError(f'axis {ax} is out of bounds for array of dimension {ndim}')
+            raise ValueError(
+                f'axis {ax} is out of bounds for array of dimension {ndim}')
 
     def canonicalizer(ax):
         return ax + ndim if ax < 0 else ax
@@ -5072,7 +5149,9 @@ 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:
+    if length_along_dim == 0:
+        res = _get_cache_prim(P.Split)(axis)(x)
+    elif indices_or_sections > length_along_dim:
         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)
@@ -5083,14 +5162,16 @@ def _tensor_split_sub_int(x, indices_or_sections, axis):
     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)
+        length1 = num_long_tensor * \
+            (length_along_dim // indices_or_sections + 1)
         length2 = length_along_dim - length1
         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 = _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))
+            _get_cache_prim(P.Split)(axis, num_short_tensor)(
+                tensor_slice(x, start2, size2))
     return res
 
 
@@ -5143,21 +5224,25 @@ def tensor_split(input, indices_or_sections, axis=0):
         raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
 
     if type(axis) is not int:
-        raise TypeError(f"Type of Argument `axis` should be integer but got {type(axis)}")
+        raise TypeError(
+            f"Type of Argument `axis` should be integer but got {type(axis)}")
     handle_axis = _canonicalize_axis(axis, input.ndim)
     if type(indices_or_sections) is int:
         if indices_or_sections > 0:
-            res = _tensor_split_sub_int(input, indices_or_sections, handle_axis)
+            res = _tensor_split_sub_int(
+                input, indices_or_sections, handle_axis)
         else:
             raise ValueError(f"For tensor_split, the value of 'indices_or_sections' must be more than zero "
                              f"but got {indices_or_sections}")
     elif isinstance(indices_or_sections, (list, tuple)):
         for item in indices_or_sections:
             if type(item) is not int:
-                raise TypeError(f"Each element in 'indices_or_sections' should be integer, but got {type(item)}.")
-        res = _tensor_split_sub_tensors(input, indices_or_sections, handle_axis)
+                raise TypeError(
+                    f"Each element in 'indices_or_sections' should be integer, but got {type(item)}.")
+        res = _tensor_split_sub_tensors(
+            input, indices_or_sections, handle_axis)
     else:
-        raise TypeError(f"Type of Argument `indices_or_sections` should be integer, tuple(int) or list(int), " \
+        raise TypeError(f"Type of Argument `indices_or_sections` should be integer, tuple(int) or list(int), "
                         f"but got {type(indices_or_sections)}")
 
     return res
@@ -5193,7 +5278,8 @@ def vsplit(input, indices_or_sections):
     if not isinstance(input, Tensor):
         raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
     if input.ndim < 1:
-        raise ValueError(f'vsplit expect `x` is a Tensor with at least 1 dimension, but got {input.ndim}')
+        raise ValueError(
+            f'vsplit expect `x` is a Tensor with at least 1 dimension, but got {input.ndim}')
     return tensor_split(input, indices_or_sections, 0)
 
 
@@ -5229,7 +5315,8 @@ def hsplit(input, indices_or_sections):
     if not isinstance(input, Tensor):
         raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
     if input.ndim < 2:
-        raise ValueError(f'hsplit expect `x` is a Tensor with at least 2 dimension, but got {input.ndim}')
+        raise ValueError(
+            f'hsplit expect `x` is a Tensor with at least 2 dimension, but got {input.ndim}')
 
     return tensor_split(input, indices_or_sections, 1)
 
@@ -5262,7 +5349,8 @@ def dsplit(input, indices_or_sections):
     if not isinstance(input, Tensor):
         raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
     if input.ndim < 3:
-        raise ValueError(f'dsplit expect `x` is a Tensor with at least 3 dimension, but got {input.ndim}')
+        raise ValueError(
+            f'dsplit expect `x` is a Tensor with at least 3 dimension, but got {input.ndim}')
 
     return tensor_split(input, indices_or_sections, 2)
 
@@ -5354,7 +5442,8 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
     if axis is None:
         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)}")
+        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)
@@ -5408,7 +5497,6 @@ def argmax(input, dim=None, keepdim=False):
     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
@@ -5471,7 +5559,8 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
     if axis is None:
         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)}")
+        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)
@@ -5584,7 +5673,8 @@ def narrow(input, axis, start, length):
     validator.check_value_type("input", input, Tensor, "narrow")
     validator.check_axis_in_range(axis, input.ndim)
     validator.check_int_range(start, 0, input.shape[axis], validator.INC_LEFT)
-    validator.check_int_range(length, 1, input.shape[axis] - start, validator.INC_BOTH)
+    validator.check_int_range(
+        length, 1, input.shape[axis] - start, validator.INC_BOTH)
 
     begins = [0] * input.ndim
     begins[axis] = start
@@ -5631,7 +5721,7 @@ def narrow_ext(input, dim, start, length):
          [ 8 9]]
     """
     validator.check_value_type("input", input, Tensor, "narrow")
-    return slice_ext_op(input, dim, start, start+length, 1)
+    return slice_ext_op(input, dim, start, start + length, 1)
 
 
 def topk(input, k, dim=None, largest=True, sorted=True):
@@ -5825,7 +5915,8 @@ def _check_unfold_params(param, param_name, param_size):
     """Check the parameters of unfold op."""
     validator.check_value_type(param_name, param, [int, tuple, list], 'unfold')
     param = (param, param) if isinstance(param, int) else param
-    validator.check(param_name + " size", len(param), "", param_size, validator.IN, 'unfold')
+    validator.check(param_name + " size", len(param), "",
+                    param_size, validator.IN, 'unfold')
     if param_name == "padding":
         validator.check_non_negative_int_sequence(param, param_name, 'unfold')
     else:
@@ -5928,7 +6019,8 @@ def _check_diagonal_axes(dim1, dim2, x_ndim):
 def _check_is_tensor(param_name, input, cls_name):
     """Returns True if input is Tensor."""
     if not isinstance(input, Tensor):
-        raise TypeError(f"For {cls_name}, {param_name} must be a Tensor, but got {type(input)}.")
+        raise TypeError(
+            f"For {cls_name}, {param_name} must be a Tensor, but got {type(input)}.")
 
 
 @_primexpr
@@ -6241,19 +6333,22 @@ def column_stack(tensors):
          [1 2]]
     """
     if not isinstance(tensors, (list, tuple)):
-        raise TypeError(f"For column_stack, the input must be list or tuple of tensors, but got {type(tensors)}.")
+        raise TypeError(
+            f"For column_stack, the input must be list or tuple of tensors, but got {type(tensors)}.")
 
     trans_x = ()
     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)}.")
+            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)
         if tensor.ndim == 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.")
+        raise ValueError(
+            f"For column_stack, the input must have at least 1 tensor, but got 0.")
     _concat = _get_cache_prim(P.Concat)(1)
     return _concat(trans_x)
 
@@ -6289,17 +6384,20 @@ def hstack(tensors):
         [1. 1. 1. 2. 2. 2.]
     """
     if not isinstance(tensors, (list, tuple)):
-        raise TypeError(f"For hstack, the input must be list or tuple, but got {type(tensors)}.")
+        raise TypeError(
+            f"For hstack, the input must be list or tuple, but got {type(tensors)}.")
 
     tuple_of_tensor = ()
     for tensor in tensors:
         if not isinstance(tensor, Tensor):
-            raise TypeError(f"For hstack, the input element must be tensor, but got {type(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)
         tuple_of_tensor += (tensor,)
     if not tuple_of_tensor:
-        raise ValueError("For hstack, the input must have at least 1 tensor, but got 0.")
+        raise ValueError(
+            "For hstack, the input must have at least 1 tensor, but got 0.")
     if tuple_of_tensor[0].ndim <= 1:
         _concat = _get_cache_prim(P.Concat)(0)
         return _concat(tuple_of_tensor)
@@ -6328,7 +6426,8 @@ def _get_moved_perm(ndim, source, destination):
     Helper function for movedim, returns permutation after moving axis
     from source to destination.
     """
-    dest_sorted_idx = [i for i, _ in sorted(enumerate(destination), key=operator.itemgetter(1))]
+    dest_sorted_idx = [i for i, _ in sorted(
+        enumerate(destination), key=operator.itemgetter(1))]
     axis_orig = [i for i in builtins.range(0, ndim) if i not in source]
 
     k = 0
@@ -6455,7 +6554,8 @@ def swapaxes(input, axis0, axis1):
         (4, 3, 2)
     '''
     if not isinstance(input, Tensor):
-        raise TypeError(f'For ops.swapaxes, parameter `input` must be Tensor, but got {type(input)}')
+        raise TypeError(
+            f'For ops.swapaxes, parameter `input` must be Tensor, but got {type(input)}')
 
     axis0, axis1 = _check_swapaxes_axis((axis0, axis1), input.ndim)
     if axis0 == axis1:
@@ -6466,10 +6566,10 @@ def swapaxes(input, axis0, axis1):
     perm = ops.make_range(0, input.ndim)
     if axis1 + 1 < input.ndim:
         new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
-                   perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1] + perm[axis1 + 1:]
+            perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1] + perm[axis1 + 1:]
     else:
         new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
-                   perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1]
+            perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1]
 
     return transpose_(input, new_perm)
 
@@ -6515,13 +6615,15 @@ def _check_is_int(arg_value, arg_name, op_name):
 
 @_primexpr
 def _check_positive_int(arg_value, arg_name, op_name):
-    arg_value = validator.check_int_range(arg_value, 0, 2147483647, validator.INC_RIGHT, arg_name, op_name)
+    arg_value = validator.check_int_range(
+        arg_value, 0, 2147483647, validator.INC_RIGHT, arg_name, op_name)
     return arg_value
 
 
 @constexpr
 def _check_axis_range(arg_value, limit, arg_name, op_name):
-    arg_value = validator.check_int_range(arg_value, -limit, limit, validator.INC_LEFT, arg_name, op_name)
+    arg_value = validator.check_int_range(
+        arg_value, -limit, limit, validator.INC_LEFT, arg_name, op_name)
     return arg_value
 
 
@@ -6539,6 +6641,14 @@ def _cal_reshape(x_shape, rep, axis):
     return tuple(x_reshape)
 
 
+@_primexpr
+def _check_rank_range(x_rank, limit, arg_name, op_name):
+    if x_rank > limit:
+        raise ValueError(
+            f"For {op_name}, the rank of {arg_name} should be less than or equal to {limit}, but got {x_rank}.")
+    return x_rank
+
+
 def repeat_interleave(input, repeats, axis=None):
     """
     Repeat elements of a tensor along an axis, like `numpy.repeat`.
@@ -6583,6 +6693,9 @@ def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
     r"""
     Repeat elements of a tensor along an axis, like `numpy.repeat`.
 
+    .. warning::
+        Only support on Atlas A2 training series.
+
     Args:
         input (Tensor): The tensor to repeat values for. Must be of type: float16,
             float32, int8, uint8, int16, int32, or int64.
@@ -6621,9 +6734,13 @@ def repeat_elements(x, rep, axis=0):
     """
     Repeat elements of a tensor along an axis, like `numpy.repeat` .
 
+    Note:
+        It is recommended to use :func:'mindspore.mint.repeat_interleave', the dimension of input 'x' can support
+        a maximum of 8, and get better performance.
+
     Args:
-        x (Tensor): The tensor to repeat values for. Must be of type: float16,
-            float32, int8, uint8, int16, int32, or int64.
+        x (Tensor): The tensor to repeat values for. Must be of type: float16, float32, int8, uint8, int16, int32,
+            or int64. The rank of `x` must be less than or equal to 7.
         rep (int): The number of times to repeat, must be positive.
         axis (int): The axis along which to repeat. Default: 0.
 
@@ -6632,6 +6749,9 @@ def repeat_elements(x, rep, axis=0):
         :math:`(s1, s2, ..., sn)` and axis is i, the output will have shape :math:`(s1, s2, ..., si * rep, ..., sn)`.
         The output type will be the same as the type of `x`.
 
+    Raises:
+        ValueError: If the rank of `x` is greater than 7.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -6658,6 +6778,7 @@ def repeat_elements(x, rep, axis=0):
     rep = _check_positive_int(rep, "rep", "repeat_elements")
     axis = _check_is_int(axis, "axis", "repeat_elements")
     x_rank = rank_(x)
+    x_rank = _check_rank_range(x_rank, 7, "x", "repeat_elements")
     axis = _check_axis_range(axis, x_rank, "axis", "repeat_elements")
     axis = axis + x.ndim if axis < 0 else axis
     expand_axis = axis + 1
@@ -6722,7 +6843,8 @@ def sequence_mask(lengths, maxlen=None):
          [[ True  True False False ]
           [ True  True  True  True ]]]
     """
-    const_utils.check_type_valid(ops.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
+    const_utils.check_type_valid(
+        ops.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
 
     if maxlen is None:
         flatten_data = reshape_(lengths, (-1,))
@@ -6733,7 +6855,8 @@ def sequence_mask(lengths, maxlen=None):
         maxlen = _check_positive_int(maxlen, "maxlen", "sequence_mask")
         maxlen = scalar_to_tensor_(maxlen, mstype.int32)
 
-    range_vector = range_(scalar_to_tensor_(0, mstype.int32), maxlen, scalar_to_tensor_(1, mstype.int32))
+    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
@@ -6747,6 +6870,221 @@ def top_k(input_x, k, sorted=True):
     return top_k_(input_x, k)
 
 
+def gather_ext(input, dim, index):
+    r"""
+    Gather data from a tensor by indices.
+
+    .. math::
+        output[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)] =
+        input[(i_0, i_1, ..., index[(i_0, i_1, ..., i_{dim}, i_{dim+1}, ..., i_n)], i_{dim+1}, ..., i_n)]
+
+    .. 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 target tensor to gather values.
+        dim (int): the axis to index along, must be in range `[-input.rank, input.rank)`.
+        index (Tensor): The index tensor, with int32 or int64 data type. An valid `index` should be:
+
+            - `index.rank == input.rank`;
+            - for `axis != dim`, `index.shape[axis] <= input.shape[axis]`;
+            - the value of `index` is in range `[-input.shape[dim], input.shape[dim])`.
+
+    Returns:
+        Tensor, has the same type as `input` and the same shape as `index`.
+
+    Raises:
+        ValueError: If the shape of `index` is illegal.
+        ValueError: If `dim` is not in `[-input.rank, input.rank)`.
+        ValueError: If the value of `index` is out of the valid range.
+        TypeError: If the type of `index` is illegal.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore.ops.function.array_func import gather_ext
+        >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
+        >>> index = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
+        >>> output = gather_ext(input, 1, index)
+        >>> print(output)
+        [[-0.1 -0.1]
+         [0.5   0.5]]
+    """
+    return gather_d_op(input, dim, index)
+
+
+def max_ext(input, dim=None, keepdim=False):
+    """
+    Calculates the maximum value along with the given dimension for the input tensor.
+
+    Args:
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        dim (int, optional): The dimension to reduce. Default: ``None`` .
+        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
+            with the input, the output will reduce dimension if false. Default: ``False`` .
+
+    Returns:
+        Tensor if `dim` is the default value ``None`` , the maximum value of input tensor, with the shape :math:`()` ,
+        and same dtype as `input`.
+
+        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the maximum
+        value of the input tensor along the given dimension `dim` and the corresponding index.
+
+        - **values (Tensor)** - The maximum value of input tensor along the given dimension `dim`, with same dtype as
+          `input`. If `keepdim` 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)` .
+        - **index (Tensor)** - The index for the maximum value of the input tensor along the given dimension `dim`, with
+          the same shape as `values`.
+
+    Raises:
+        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore.ops.function.array_func import max_ext
+        >>> y = Tensor(np.array([[0.0, 0.3, 0.4, 0.5, 0.1],
+        ...                      [3.2, 0.4, 0.1, 2.9, 4.0]]), mindspore.float32)
+        >>> output, index = max_ext(y, 0, True)
+        >>> print(output, index)
+        [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
+    """
+    if dim is None:
+        if keepdim is not False:
+            raise ValueError(
+                f"For 'max', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
+        return max_(input)
+    argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(dim, keepdim)
+    indices, values = argmax_with_value_op(input)
+    return values, indices
+
+
+def min_ext(input, dim=None, keepdim=False):
+    """
+    Calculates the minimum value along with the given dimension for the input tensor.
+
+    Args:
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        dim (int, optional): The dimension to reduce. Default: ``None`` .
+        keepdim (bool, optional): Whether to reduce dimension, if true, the output will keep same dimension
+            with the input, the output will reduce dimension if false. Default: ``False`` .
+
+    Returns:
+        Tensor if `dim` is the default value ``None`` , the minimum value of input tensor, with the shape :math:`()` ,
+        and same dtype as `input`.
+
+        tuple (Tensor) if `dim` is not the default value ``None`` , tuple of 2 tensors, containing the minimum value
+        of the input tensor along the given dimension `dim` and the corresponding index.
+
+        - **values (Tensor)** - The minimum value of input tensor along the given dimension `dim`, with same dtype as
+          `input`. If `keepdim` 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)` .
+        - **index (Tensor)** - The index for the minimum value of the input tensor along the given dimension `dim`,
+          with the same shape as `values`.
+
+    Raises:
+        ValueError: If `dim` is the default value ``None`` and `keepdim` is not ``False`` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore.ops.function.array_func import min_ext
+        >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
+        >>> output, index = min_ext(x, 0, keepdim=True)
+        >>> print(output, index)
+        [0.0] [0]
+    """
+    if dim is None:
+        if keepdim is not False:
+            raise ValueError(
+                f"For 'min', the `keepdim` must be False when the `dim` is None, but got {keepdim}")
+        return min_(input)
+    argmin_with_value_op = _get_cache_prim(ArgMinWithValue)(dim, keepdim)
+    indices, values = argmin_with_value_op(input)
+    return values, indices
+
+
+def one_hot_ext(tensor, num_classes):
+    r"""
+    Computes a one-hot tensor.
+
+    The locations represented by tensor in `tensor` take value `1`, while all
+    other locations take value `0`.
+
+    Args:
+        tensor (Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
+            Data type must be int32 or int64.
+        num_classes (int): A scalar defining the depth of the one-hot dimension.
+
+    Returns:
+        Tensor, one-hot tensor.
+
+    Raises:
+        TypeError: If `num_classes` is not an int.
+        TypeError: If dtype of `tensor` is not int32 or int64.
+        ValueError: If `num_classes` is less than 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.function.array_func import one_hot_ext
+        >>> tensor = Tensor(np.array([0, 1, 2]), mindspore.int32)
+        >>> num_classes = 3
+        >>> output = one_hot_ext(tensor, num_classes)
+        >>> print(output)
+        [[1. 0. 0.]
+        [0. 1. 0.]
+        [0. 0. 1.]]
+    """
+    on_value = Tensor(1, dtype=tensor.dtype)
+    off_value = Tensor(0, dtype=tensor.dtype)
+    return one_hot_ext_impl(tensor, num_classes, on_value, off_value, -1)
+
+
+def from_numpy(array):
+    r"""
+    Convert numpy array to Tensor.
+    If the data is not C contiguous, the data will be copied to C contiguous to construct the tensor.
+    Otherwise, the tensor will be constructed using this numpy array without copy.
+
+    Args:
+        array (numpy.array): The input array.
+
+    Returns:
+        Tensor, has the same data type as input array.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> x = np.array([1, 2])
+        >>> output = ms.from_numpy(x)
+        >>> print(output)
+        [1 2]
+    """
+    return Tensor.from_numpy(array)
+
 __all__ = [
     'unique',
     'unique_with_pad',
@@ -6763,6 +7101,7 @@ __all__ = [
     'ones_like',
     'zeros',
     'zeros_like',
+    'zero_',
     'shape',
     'shape_',
     'reverse',