mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/function/array_func.py

@@ -24,7 +24,6 @@ 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
@@ -32,10 +31,9 @@ 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
 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.gen_ops_prim import SplitWithSize, RepeatInterleave
 
 from mindspore.ops.operations.array_ops import (
     UniqueConsecutive,
@@ -53,8 +51,6 @@ from mindspore.ops.operations.array_ops import (
     Expand,
     Lstsq,
     Mvlgamma,
-    Tril,
-    Argmax,
     ArgMaxWithValue,
     ArgMinWithValue
 )
@@ -66,13 +62,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, \
+    nonzero, flip, transpose, tril, 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.auto_generate.gen_ops_prim import scatter_add_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()
@@ -133,15 +128,9 @@ 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()
+repeat_interleave_ = RepeatInterleave()
 
 
 @_primexpr
@@ -286,10 +275,13 @@ def arange_ext(start=0, end=None, step=1, *, dtype=None):
     `step` up to but not including `end`.
 
     Args:
-        start (Union[float, int], optional): The start of the interval. Default: ``0`` .
-        end (Union[float, int], optional): The end of the interval, exclusive.
+        start (Union[float, int, Tensor], optional): The start of the interval.
+            If Tensor, the shape must be :math:`()` . Default: ``0`` .
+        end (Union[float, int, Tensor], optional): The end of the interval, exclusive.
+            If Tensor, the shape must be :math:`()`.
             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`` .
+        step (Union[float, int, Tensor], optional): Number that increments `start`.
+            If Tensor, the shape must be :math:`()`. Default: ``1`` .
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The required data type of returned Tensor. Default: ``None`` .
@@ -300,10 +292,11 @@ def arange_ext(start=0, end=None, step=1, *, dtype=None):
             If `start`, `end`, and `step` contain at least one floating-point number, the dtype of output is float32.
 
     Returns:
-        A 1-D Tensor, cast to `dtype` if provided, may potentially lose precision due to casting.
+        A 1-D Tensor, with the same type as the inputs.
 
     Raises:
-        TypeError: If `start`, `end` or `step` are not of type int or float.
+        TypeError: If `start`, `end` or `step` is not an int or a float or a TensorScalar(Special Tensor with shape ())
+                   in valid dtypes.
         ValueError: If `step` = 0.
         ValueError: If `start` >= `end` when `step` > 0.
         ValueError: If `start` <= `end` when `step` < 0.
@@ -313,31 +306,35 @@ def arange_ext(start=0, end=None, step=1, *, dtype=None):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import Tensor, ops
-        >>> output = ops.arange_ext(1, 6)
+        >>> from mindspore import Tensor, mint
+        >>> output = mint.arange(1, 6)
         >>> print(output)
         [1 2 3 4 5]
         >>> print(output.dtype)
         Int64
-        >>> output = ops.arange_ext(0, 3, 1.2)
+        >>> output = mint.arange(0, 3, 1.2)
         >>> print(output)
         [0.  1.2 2.4]
         >>> print(output.dtype)
         Float32
-        >>> output = ops.arange_ext(7, 1, -2)
+        >>> output = mint.arange(7, 1, -2)
         >>> print(output)
         [7 5 3]
         >>> print(output.dtype)
         Int64
-        >>> output = ops.arange_ext(12, 2, -1, dtype=ms.bfloat16))
+        >>> output = mint.arange(ms.Tensor(12.0, dtype=ms.float64), 2, ms.Tensor(-1.0, dtype=ms.float32))
         >>> print(output)
         [12. 11. 10.  9.  8.  7.  6.  5.  4.  3.]
         >>> print(output.dtype)
-        BFloat16
+        Float32
     """
     if end is None:
         start, end = 0, start
-    return arange_(start, end, step, dtype)
+
+    out = arange_(start, end, step)
+    if dtype is not None:
+        out = cast_(out, dtype)
+    return out
 
 
 def concat(tensors, axis=0):
@@ -1078,9 +1075,7 @@ def zeros_like(input, *, dtype=None):
 
 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.
-
-    If `dtype = None`, the tensor will have the same dtype as input `input`.
+    Returns a Tensor with a value of 1 and its shape is the same as the input.
 
     Args:
         input (Tensor): Tensor of any dimension.
@@ -1102,7 +1097,7 @@ def ones_like_ext(input, *, dtype=None):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-        >>> output = ops.function.array_func.ones_like_ext(x)
+        >>> output = ops.mint.ones_like(x)
         >>> print(output)
         [[1 1]
          [1 1]]
@@ -1112,7 +1107,7 @@ def ones_like_ext(input, *, dtype=None):
 
 def zeros_like_ext(input, *, dtype=None):
     r"""
-    Creates a tensor filled with 0, with the same size as input. Its data type is determined by 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`.
 
@@ -1137,7 +1132,7 @@ def zeros_like_ext(input, *, dtype=None):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.arange(4).reshape(2, 2))
-        >>> output = ops.function.array_func.zeros_like_ext(x, dtype=mindspore.float32)
+        >>> output = ops.mint.zeros_like(x, dtype=mindspore.float32)
         >>> print(output)
         [[0. 0.]
          [0. 0.]]
@@ -1204,77 +1199,6 @@ def unique(input):
     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
-        >>> 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_ext(x, return_inverse=True)
-        >>> print(output)
-        (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]
-        >>> idx = output[1]
-        >>> print(idx)
-        [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")
-    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):
     """
     Returns unique elements and relative indexes in 1-D tensor, filled with padding num.
@@ -1380,7 +1304,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, side=None, sorter=None):
+def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
     """
     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.
@@ -1395,12 +1319,6 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=
             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,
@@ -1411,8 +1329,6 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=
     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``
@@ -1429,16 +1345,10 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=
          [1 2 4]]
     """
 
-    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
+    _check_attr_dtype("out_int32", out_int32, [bool], "search_sorted")
+    dtype = mstype.int64 if not out_int32 else mstype.int32
     search_sorted_ = SearchSorted(dtype, right)
-    return search_sorted_(sorted_sequence, values, sorter)
+    return search_sorted_(sorted_sequence, values)
 
 
 def ger(input, vec2):
@@ -2868,59 +2778,6 @@ def sort(input_x, axis=-1, descending=False):
     return _sort(input_x)
 
 
-def sort_ext(input, *, dim=-1, descending=False, stable=False):
-    r"""
-    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.
-            The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-
-    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:
-        - 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 `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``
-
-    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)
-        (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]]))
-    """
-    return sort_ext_(input, dim, descending, stable)
-
-
 def argsort(input, axis=-1, descending=False):
     r"""
     Sorts the input tensor along the given dimension in specified order and return the sorted indices.
@@ -3386,42 +3243,29 @@ def scatter(input, axis, index, src):
 
 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
+    Update the value in `src` to `input` according to the specified index.
 
     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`.
+        input (Tensor): The target tensor. The rank of `input` must be at least 1.
+        dim (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` .
 
     Returns:
-        Tensor, has the same shape and type as `input`.
+        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`.
+        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 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.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -3430,29 +3274,29 @@ def scatter_add_ext(input, dim, index, src):
         >>> 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)
+        >>> out = ops.scatter_add_ext(input=input, dim=1, index=index, src=src)
         >>> print(out)
-        [[1. 2. 11. 4. 13.]]
+        [[1. 2. 8. 4. 8.]]
         >>> 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)
+        >>> out = ops.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.]]
+        [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)
+        >>> out = ops.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.]]
+        [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)
 
@@ -3985,7 +3829,7 @@ def meshgrid(*inputs, indexing='xy'):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as 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))
@@ -4068,7 +3912,7 @@ def affine_grid(theta, size, align_corners=False):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as 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)
@@ -4261,7 +4105,7 @@ def index_fill(x, axis, index, value):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import ops
+        >>> import mindspore.ops as 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)
@@ -4884,8 +4728,8 @@ def split_ext(tensor, split_size_or_sections, axis=0):
 
     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 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 `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].
@@ -4897,7 +4741,7 @@ def split_ext(tensor, split_size_or_sections, axis=0):
         >>> import numpy as np
         >>> from mindspore import ops, Tensor
         >>> input_x = np.arange(9).astype("float32")
-        >>> output = ops.split_ext(Tensor(input_x), 3)
+        >>> output = ops.split(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]),
@@ -4913,67 +4757,6 @@ def split_ext(tensor, split_size_or_sections, axis=0):
     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),
-    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 `x`.
-
-    Raises:
-        TypeError: If `x` 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.
-
-    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.tril(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.tril(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.tril(x, diagonal=-1)
-        >>> print(result)
-        [[ 0  0  0  0]
-         [ 5  0  0  0]
-         [10 11  0  0]
-         [14 15 16  0]]
-    """
-    tril_ = Tril(diagonal)
-    return tril_(input)
-
-
 @_primexpr
 def _canonicalize_axis(axis, ndim):
     """
@@ -5363,52 +5146,6 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
     return values, indices
 
 
-def argmax(input, dim=None, keepdim=False):
-    """
-    Return the indices of the maximum values of a tensor across a dimension.
-
-    Args:
-        input (Tensor): Input tensor.
-        dim (Union[int, None], optional): The dimension to reduce. If `dim` is ``None`` , the indices of the maximum
-            value within the flattened input will be returned. Default: ``None`` .
-        keepdim (bool, optional): Whether the output tensor retains the specified
-            dimension. Ignored if `dim` is None. Default: ``False`` .
-
-    Returns:
-        Tensor, indices of the maximum values across a dimension.
-
-    Raises:
-        TypeError: If `keepdim` is not bool.
-        ValueError: If `dim` is out of range.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
-        >>> output = ops.argmax(x, dim=-1)
-        >>> print(output)
-        [1 0 0]
-    """
-    _check_attr_dtype("keepdim", keepdim, [bool], "argmax")
-    if not input.shape:
-        return Tensor(0)
-    if input.dtype == mstype.bool_:
-        input = input.astype(mstype.int32)
-    is_dim_none = False
-    if dim is None:
-        input = reshape_(input, (-1,))
-        dim = 0
-        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)
-    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
@@ -5593,47 +5330,6 @@ def narrow(input, axis, start, length):
     return tensor_slice(input, begins, sizes)
 
 
-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 (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.
-
-    Raises:
-        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``
-
-    Examples:
-        >>> import mindspore
-        >>> 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)
-        [[ 1 2 3]
-         [ 4 5 6]]
-        >>> output = ops.narrow(x, 1, 1, 2)
-        >>> print(output)
-        [[ 2 3]
-         [ 5 6]
-         [ 8 9]]
-    """
-    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):
     r"""
     Finds values and indices of the `k` largest or smallest entries along a given dimension.
@@ -5725,6 +5421,80 @@ def topk(input, k, dim=None, largest=True, sorted=True):
     return res
 
 
+def topk_ext(input, k, dim=-1, largest=True, sorted=True):
+    r"""
+    Finds values and indices of the `k` largest or smallest entries along a given dimension.
+
+    .. warning::
+        - If sorted is set to False, it will use the aicpu operator, the performance may be reduced. In addition, due to
+          different memory layout and traversal methods on different platforms, the display order of calculation results
+          may be inconsistent when `sorted` is False.
+
+    If the `input` is a one-dimensional Tensor, finds the `k` largest  or smallest entries in the Tensor,
+    and outputs its value and index as a Tensor. values[`k`] is the `k` largest item in `input`,
+    and its index is indices [`k`].
+
+    For a multi-dimensional matrix,
+    calculates the first or last `k` entries in a given dimension, therefore:
+
+    .. math::
+
+        values.shape = indices.shape
+
+    If the two compared elements are the same, the one with the smaller index value is returned first.
+
+    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.
+        dim (int, optional): The dimension to sort along. Default: ``-1`` .
+        largest (bool, optional): If largest is ``False``  then the k smallest elements are returned.
+            Default: ``True`` .
+        sorted (bool, optional): If ``True`` , the obtained elements will be sorted by the values in descending order.
+            If ``False`` , the obtained elements will not be sorted. Default: ``True`` .
+
+    Returns:
+        A tuple consisting of `values` and `indexes`.
+
+        - values (Tensor): The `k` largest or smallest elements in each slice of the given dimension.
+        - indices (Tensor): The indices of values within the last dimension of input.
+
+    Raises:
+        TypeError: If `sorted` is not a bool.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `k` is not an int.
+        TypeError: If dtype of `input` is not one of the following: float16, float32 or int32.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> x = ms.Tensor([[0.5368, 0.2447, 0.4302, 0.9673],
+        ...                [0.4388, 0.6525, 0.4685, 0.1868],
+        ...                [0.3563, 0.5152, 0.9675, 0.8230]], dtype=ms.float32)
+        >>> output = ops.topk_ext(x, 2, dim=1)
+        >>> print(output)
+        (Tensor(shape=[3, 2], dtype=Float32, value=
+        [[ 9.67299998e-01,  5.36800027e-01],
+         [ 6.52499974e-01,  4.68499988e-01],
+         [ 9.67499971e-01,  8.23000014e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
+        [[3, 0],
+         [1, 2],
+         [2, 3]]))
+        >>> output2 = ops.topk(x, 2, dim=1, largest=False)
+        >>> print(output2)
+        (Tensor(shape=[3, 2], dtype=Float32, value=
+        [[ 2.44700000e-01,  4.30200011e-01],
+         [ 1.86800003e-01,  4.38800007e-01],
+         [ 3.56299996e-01,  5.15200019e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
+        [[1, 2],
+         [3, 0],
+         [0, 1]]))
+    """
+    return _get_cache_prim(ops.auto_generate.TopkExt)()(input, k, dim, largest, sorted)
+
+
 def expand(input_x, size):
     r"""
     :func:`mindspore.ops.expand` will be deprecated in the future.
@@ -5788,8 +5558,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 `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
+        TypeError: If `kernel_size`, `dilation`, `padding`, `stride` data type is not int, tuple or list.
+        ValueError: If `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]`
@@ -6122,64 +5892,6 @@ 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.
@@ -6447,7 +6159,7 @@ def swapaxes(input, axis0, axis1):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapaxes(input, 0, 2)
@@ -6497,7 +6209,7 @@ def swapdims(input, dim0, dim1):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapdims(input, 0, 2)
@@ -6579,23 +6291,18 @@ def repeat_interleave(input, repeats, axis=None):
     return output
 
 
-def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
+def repeat_interleave_ext(tensor, repeats, axis=None, output_size=None):
     r"""
-    Repeat elements of a tensor along an axis, like `numpy.repeat`.
+    Repeat elements of a tensor.
 
     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``.
+        tensor (Tensor): the input tensor.
+        repeats (Union[int, list, tuple, Tensor]) the number of repetitions for each element
+        axis (int, optional) the axis along wich to repeat, if None, defaults to 0.
+        output_size (int, optional): Calculated output size along specified axis.
 
     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`.
+        Tensor, one-hot tensor.
 
     Supported Platforms:
         ``Ascend``
@@ -6603,18 +6310,32 @@ def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
     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)
+        >>> from mindspore import mint
+        >>> from mindspore import Tensor
+        >>> tensor = Tensor(np.array([0, 1, 2], [3, 4, 5]), mindspore.int32)
+        >>> repeats = 2
+        >>> axis = 0
+        >>> output = mint.repeat_interleave(tensor, repeats, axis)
         >>> print(output)
-        [[0 1 2]
-         [0 1 2]
-         [3 4 5]
-         [3 4 5]]
+        [[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)
+    if axis is None:
+        tensor = tensor.ravel()
+        axis = 0
+
+    size = tensor.shape[axis]
+    if output_size is None:
+        if isinstance(repeats, int):
+            output_size = size*repeats
+        elif len(repeats) == 1:
+            output_size = size*repeats[0]
+        else:
+            output_size = sum(repeats)
+
+    return repeat_interleave_(tensor, repeats, axis, output_size)
 
 
 def repeat_elements(x, rep, axis=0):
@@ -6761,8 +6482,10 @@ __all__ = [
     'ger',
     'ones',
     'ones_like',
+    'ones_like_ext',
     'zeros',
     'zeros_like',
+    'zeros_like_ext',
     'shape',
     'shape_',
     'reverse',
@@ -6770,6 +6493,7 @@ __all__ = [
     'hamming_window',
     'chunk',
     'full',
+    'full_ext',
     'full_like',
     'dyn_shape',
     'rank',
@@ -6828,6 +6552,7 @@ __all__ = [
     'narrow',
     'ravel',
     'scatter_add',
+    'scatter_add_ext',
     'scatter_mul',
     'scatter_max',
     'scatter_min',
@@ -6856,7 +6581,6 @@ __all__ = [
     'index_fill',
     'index_select',
     'max',
-    'argmax',
     'min',
     'unsorted_segment_sum',
     'population_count',
@@ -6884,6 +6608,6 @@ __all__ = [
     'sort',
     'top_k',
     'deepcopy',
-    'flip',
+    'flip'
 ]
 __all__.sort()