mindspore 2.4.10__cp311-cp311-manylinux1_x86_64.whl → 2.5.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/ops/function/array_func.py

@@ -33,12 +33,12 @@ 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, Scatter, ScatterValue
-from mindspore.ops.auto_generate.gen_ops_prim import SplitTensor
+    Unique2, SortExt, NonZero, NonZeroExt, Scatter, ScatterValue, NewOnes, NewZeros
+from mindspore.ops.auto_generate.gen_ops_prim import SplitTensor, Meshgrid
 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.auto_generate.pyboost_inner_prim import _PyboostSearchSortedPrim, meshgrid_impl, \
+    unique_consecutive_impl
 from mindspore.ops.operations.array_ops import (
-    UniqueConsecutive,
     MatrixDiagV3,
     MatrixDiagPartV3,
     MatrixSetDiagV3,
@@ -60,16 +60,21 @@ from mindspore.ops.operations.array_ops import (
 from mindspore.common import Tensor
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as validator
-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, masked_select, \
-    broadcast_to, strided_slice, ones, zeros, max_, min_, select, zero_
+    broadcast_to, strided_slice, ones, zeros, max_, min_, select, zero_, view_as, \
+    expand_as, unstack_ext_op, full_like_op, \
+    index_fill_scalar, index_fill_tensor
 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.auto_generate.gen_ops_prim import scatter_add_ext_op, gather_d_op, slice_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
+from mindspore._c_expression import pyboost_empty
+from mindspore._c_expression import pyboost_empty_like
+from mindspore._c_expression import pyboost_new_empty
+from mindspore.common._stub_tensor import _convert_stub
 
 arg_max_with_value_ = ArgMaxWithValue()
 arg_min_with_value_ = ArgMinWithValue()
@@ -116,9 +121,10 @@ tensor_scatter_mul_ = P.TensorScatterMul()
 tensor_scatter_sub_ = P.TensorScatterSub()
 tensor_select_ = P.Select()
 tensor_shape_ = P.TensorShape()
-tensor_slice = P.Slice()
+tensor_slice = slice_op
 tile_ = P.Tile()
 transpose_ = P.Transpose()
+type_as_ = P.TypeAs()
 tuple_to_array_ = P.TupleToArray()
 tuple_to_tensor_ = TupleToTensor()
 unique_ = P.Unique()
@@ -131,10 +137,12 @@ one_hot_ext_impl = _PyboostOneHotExtPrim()
 zeros_like_ = P.ZerosLike()
 ones_like_ext_ = OnesLikeExt()
 zeros_like_ext_ = ZerosLikeExt()
+new_ones_ = NewOnes()
+new_zeros_ = NewZeros()
 fill_scalar_ = FillScalar()
 fill_tensor_ = FillTensor()
 sort_ext_ = SortExt()
-scatter_ = Scatter()
+scatter_prim = Scatter()
 scatter_value_ = ScatterValue()
 arange_ = Arange()
 chunk_ = Chunk()
@@ -521,12 +529,97 @@ def where(condition, input, other):
 
 def reverse(x, axis):
     """
-    :func:`mindspore.ops.reverse` will be deprecated in the future.
-    Please use :func:`mindspore.ops.flip` instead.
+    This interface will be deprecated in the future, and use :func:`mindspore.ops.flip` instead.
     """
     return flip(x, axis)
 
 
+def empty(*size, dtype=None, device=None):
+    r"""
+    Creates a tensor with uninitialized data, whose shape, dtype and device are described by the argument `size`,
+    `dtype` and `device` respectively.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Only positive integer or
+            tuple or list containing positive integers are allowed.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
+            `mindspore.float32` will be used. Default: ``None`` .
+        device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
+            `device = None`, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
+
+    Returns:
+        Tensor, whose dtype and size are defined by input.
+
+    Raises:
+        TypeError: If `size` is neither an int nor a tuple or list of int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> output = ops.empty((2, 3), dtype=mindspore.float32)
+        >>> print(output)
+        [[0. 0. 0.]
+         [0. 0. 0.]]
+    """
+
+    return _convert_stub(pyboost_empty([size, dtype, device]))
+
+def empty_like(input, *, dtype=None, device=None):
+    r"""
+    Returns an uninitialized Tensor with the same shape as the `input`. Its dtype is specified by `dtype` and its
+    device is specified by `device`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`, the
+            tensor will have the same dtype as input `input`. Default ``None``.
+        device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
+            `device = None`, the tensor will have the same device as input `input` and if the device of the input
+            tensor is not defined, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
+
+    Returns:
+        Tensor, has the same shape, type and device as `input` but with uninitialized data (May be a random value).
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops, Tensor
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
+        >>> output1 = ops.empty_like(x)
+        >>> print(output1)
+        [[0 0 0]
+         [0 0 0]]
+        >>> output2 = ops.empty_like(x, dtype=mindspore.float64)
+        >>> print(output2)
+        [[0. 0. 0.]
+         [0. 0. 0.]]
+    """
+
+    return _convert_stub(pyboost_empty_like([input, dtype, device]))
+
+
+def new_empty(input, size, dtype, device):
+    return _convert_stub(pyboost_new_empty([input, size, dtype, device]))
+
+
 def ravel(input):
     """
     Expand the multidimensional Tensor into 1D along the 0 axis direction.
@@ -818,7 +911,8 @@ def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-oute
             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,
+        dtype (mindspore.dtype, optional): The specified type of output tensor.
+            `bool_` and `number` are supported, for details,
             please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
@@ -890,6 +984,50 @@ def full_like(input, fill_value, *, dtype=None):
     return full(input.shape, fill_value, dtype=dtype)
 
 
+def full_like_ext(input, fill_value, *, dtype=None):
+    """
+    Return a Tensor of the same shape as `input` and filled with `fill_value`.
+
+    .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): input Tensor and the output Tensor have the same shape as `input`.
+        fill_value (Number): Value to fill the returned tensor. Complex numbers are not supported for now.
+
+    Keyword Args:
+        dtype (mindspore.dtype, optional): The specified type of output tensor. `bool_` and `number` are supported,
+            for details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
+        >>> output = mint.full_like(input, 1)
+        >>> print(output)
+        [[1 1]
+         [1 1]]
+        >>> input = Tensor([[0, 1, 1], [2, 1, 2], [1, 3, 4]], dtype=mindspore.int32)
+        >>> output = mint.full_like(input, 0, dtype=mindspore.float32)
+        >>> print(output)
+        [[0. 0. 0.]
+         [0. 0. 0.]
+         [0. 0. 0.]]
+    """
+    if dtype is None:
+        dtype = input.dtype
+    return full_like_op(input, fill_value, dtype)
+
+
 def chunk(input, chunks, axis=0):
     """
     Cut the input Tensor into `chunks` sub-tensors along the specified axis.
@@ -1167,6 +1305,82 @@ def zeros_like_ext(input, *, dtype=None):
     return zeros_like_ext_(input, dtype)
 
 
+def new_ones(input, size, *, dtype=None):
+    """
+    Return a tensor of `size` filled with ones.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+        size (Union[int, tuple(int), list(int)]): An int, list or tuple of integers defining the output shape.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired dtype of the output tensor. If None, the returned
+            tensor has the same dtype as `self`. Default: ``None``.
+
+    Returns:
+        Tensor, the shape and dtype is defined above and filled with ones.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `size` is neither an int nor a tuple/list of int.
+        TypeError: If `dtype` is not a MindSpore dtype.
+        ValueError: If `size` contains negative values.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([1, 2, 3, 4], mindspore.int32)
+        >>> output = ops.function.array_func.new_ones(input, (2, 3))
+        >>> print(output)
+        [[1 1 1]
+         [1 1 1]]
+    """
+    return new_ones_(input, size, dtype)
+
+
+def new_zeros(input, size, *, dtype=None):
+    """
+    Return a tensor of `size` filled with zeros.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+        size (Union[int, tuple(int), list(int)]): An int, list or tuple of integers defining the output shape.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired dtype of the output tensor. If None, the returned
+            tensor has the same dtype as `self`. Default: ``None``.
+
+    Returns:
+        Tensor, the shape and dtype is defined above and filled with zeros.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `size` is neither an int nor a tuple/list of int.
+        TypeError: If `dtype` is not a MindSpore dtype.
+        ValueError: If `size` contains negative values.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([1, 2, 3, 4], mindspore.int32)
+        >>> output = ops.function.array_func.new_zeros(input, (2, 3))
+        >>> print(output)
+        [[0 0 0]
+         [0 0 0]]
+    """
+    return new_zeros_(input, size, dtype)
+
+
 ##############################
 # Tensor Operation Functions.
 ##############################
@@ -1233,16 +1447,17 @@ def unique_ext(input, sorted=True, return_inverse=False, return_counts=False, di
     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
+    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.
+        sorted (bool, optional): 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
+        return_inverse (bool, optional): 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.
+        return_counts (bool, optional): Whether to also return the counts for each unique element. Default: ``False`` .
+        dim (int, optional): 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`` .
 
@@ -1397,11 +1612,10 @@ def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
         [2 2 1 2 1]
     """
 
-    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)
-    output, idx, counts = unique_consecutive_op(input)
+    if not F.isconstant(return_idx) or not F.isconstant(return_counts):
+        raise ValueError(
+            f"For 'unique_consecutive', 'return_inverse' and 'return_counts' cannot be mutable")
+    output, idx, counts = unique_consecutive_impl(input, return_idx, return_counts, axis)
     if return_idx and return_counts:
         return output, idx, counts
     if return_idx:
@@ -1928,6 +2142,44 @@ def unbind(input, dim=0):
     return _unstack(input)
 
 
+def unbind_ext(input, dim=0):
+    r"""
+    Unbind a tensor dimension in specified axis.
+
+    Given a tensor of shape :math:`(n_1, n_2, ..., n_R)` and unbinding it in the specified `dim`,
+    multiple tensors with shape :math:`(n_1, n_2, ..., n_{dim}, n_{dim+2}, ..., n_R)` are returned.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor to unbind, with a shape of :math:`(n_1, n_2, ..., n_R)`.
+            The rank of the tensor must be greater than 0.
+        dim (int, optional): Dimension along which to unbind. The range is [-R, R). Default: ``0`` .
+
+    Returns:
+        A tuple of tensors, the shape of each objects is the same.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is out of the range [-R, R).
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+        >>> output = ops.unbind_ext(input, dim=0)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Int64, value=[1, 2, 3]), Tensor(shape=[3], dtype=Int64, value=[4, 5, 6]),
+        Tensor(shape=[3], dtype=Int64, value=[7, 8, 9]))
+    """
+    return unstack_ext_op(input, dim)
+
+
 def unsqueeze(input, dim):
     """
     Adds an additional dimension to `input` at the given dim.
@@ -1970,14 +2222,17 @@ def squeeze(input, axis=None):
     If `axis` is specified, it will remove the dimensions of size 1 in the given `axis`.
     For example, if the dimension is not specified :math:`axis=None`, input shape is (A, 1, B, C, 1, D),
     then the shape of the output Tensor is (A, B, C, D). If the dimension is specified, the squeeze operation
-    is only performed in the specified dimension. If input shape is (A, 1, B), input Tensor will be changed
-    to (A, B) when :math:`axis=1`, but when :math:`axis=0` or :math:`axis=2`, an error will occur.
+    is only performed in the specified dimension. If input shape is (A, 1, B), when :math:`axis=0` or :math:`axis=2`,
+    the input tensor is not changed, while when :math:`axis=1`, the input tensor shape is changed to (A, B).
 
     Note:
-        - Squeezing a dimension that is not 1 will raise an error.
         - Please note that in dynamic graph mode, the output Tensor will share data with the input Tensor,
           and there is no Tensor data copy process.
         - The dimension index starts at 0 and must be in the range `[-input.ndim, input.ndim]`.
+        - In GE mode, only support remove dimensions of size 1 from the shape of input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
@@ -1992,7 +2247,6 @@ def squeeze(input, axis=None):
         TypeError: If `input` is not a tensor.
         TypeError: If `axis` is not an int, tuple or list.
         TypeError: If `axis` is a tuple or list whose elements are not all int.
-        ValueError: If the corresponding dimension of the specified axis isn't equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2033,7 +2287,7 @@ def scatter_mul(input_x, indices, updates):
     when the data types of parameters need to be converted.
 
     Args:
-        input_x (Parameter): The target tensor to be updated, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor to be updated, with data type of Parameter or Tensor.
             The shape is :math:`(N,*)` where :math:`*` means any number of additional dimensions.
         indices (Tensor): The index to do mul operation whose data type must be int32 or int64.
         updates (Tensor): The tensor doing the mul operation with `input_x`,
@@ -2045,8 +2299,8 @@ def scatter_mul(input_x, indices, updates):
     Raises:
         TypeError: If `indices` is not an int32 or int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2132,7 +2386,7 @@ def scatter_max(input_x, indices, updates):
     required by `input_x`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
             The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         indices (Tensor): The index to do max operation whose data type must be mindspore.int32.
         updates (Tensor): The tensor doing the max operation with `input_x`,
@@ -2144,8 +2398,8 @@ def scatter_max(input_x, indices, updates):
     Raises:
         TypeError: If `indices` is not an int32 or int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2173,7 +2427,7 @@ def scatter_add(input_x, indices, updates):
     This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do add operation whose data type must be int32 or int64.
         updates (Tensor): The tensor doing the add operation with `input_x`,
             the data type is same as `input_x`, the shape is `indices.shape + x.shape[1:]`.
@@ -2184,8 +2438,8 @@ def scatter_add(input_x, indices, updates):
     Raises:
         TypeError: If `indices` is not an int32 or int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-            is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2225,7 +2479,7 @@ def scatter_min(input_x, indices, updates):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do min operation whose data type must be mindspore.int32 or mindspore.int64.
         updates (Tensor): The tensor doing the min operation with `input_x`,
             the data type is same as `input_x`, the shape is `indices.shape + input_x.shape[1:]`.
@@ -2236,8 +2490,8 @@ def scatter_min(input_x, indices, updates):
     Raises:
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2277,7 +2531,7 @@ def scatter_div(input_x, indices, updates):
     when `updates` does not support conversion to the data type required by `input_x`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do divide operation whose data type must be mindspore.int32 or
           mindspore.int64.
         updates (Tensor): The tensor doing the divide operation with `input_x`, the data type is same as `input_x`,
@@ -2289,8 +2543,8 @@ def scatter_div(input_x, indices, updates):
     Raises:
         TypeError: If the type of `indices` is not one of the following dtype: int32, int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter is required
-                      when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter or Tensor is required
+                      when data type conversion of Parameter or Tensor is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2363,7 +2617,7 @@ def scatter_update(input_x, indices, updates):
     the relatively highest priority data type.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index of input tensor. With int32 or int64 data type.
             If there are duplicates in indices, the order for updating is undefined.
         updates (Tensor): The tensor to update the input tensor, has the same type as input,
@@ -2375,8 +2629,8 @@ def scatter_update(input_x, indices, updates):
     Raises:
         TypeError: If `indices` is not an int32 or an int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2415,7 +2669,7 @@ def scatter_nd_add(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do min operation whose data type must be mindspore.int32 or mindspore.int64.
             The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor doing the addition operation with `input_x`,
@@ -2430,8 +2684,8 @@ def scatter_nd_add(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2490,7 +2744,7 @@ def scatter_nd_sub(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index of input tensor, with int32 or int64 data type.
             The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor doing the subtraction operation with `input_x`, has the same type as input.
@@ -2505,8 +2759,8 @@ def scatter_nd_sub(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2565,7 +2819,7 @@ def scatter_nd_mul(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): Input parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do multiplication operation whose data type must be mindspore.int32 or
             mindspore.int64. The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor to do the multiplication operation with `input_x`.
@@ -2580,8 +2834,8 @@ def scatter_nd_mul(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -2640,7 +2894,7 @@ def scatter_nd_div(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do div operation whose data type must be mindspore.int32 or mindspore.int64.
             The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor to do the div operation with `input_x`.
@@ -2655,8 +2909,8 @@ def scatter_nd_div(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -2716,7 +2970,7 @@ def scatter_nd_max(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do maximum operation whose data type must be mindspore.int32 or mindspore.int64.
             The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor to do the max operation with `input_x`.
@@ -2731,8 +2985,8 @@ def scatter_nd_max(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2791,7 +3045,7 @@ def scatter_nd_min(input_x, indices, updates, use_locking=False):
     :math:`(i_0, i_1, ..., i_{Q-2}, x\_shape_N, ..., x\_shape_{P-1})`.
 
     Args:
-        input_x (Parameter): The target tensor, with data type of Parameter.
+        input_x (Union[Parameter, Tensor]): The target tensor, with data type of Parameter or Tensor.
         indices (Tensor): The index to do min operation whose data type must be mindspore.int32 or mindspore.int64.
             The rank of indices must be at least 2 and `indices.shape[-1] <= len(shape)`.
         updates (Tensor): The tensor to do the min operation with `input_x`.
@@ -2806,8 +3060,8 @@ def scatter_nd_min(input_x, indices, updates, use_locking=False):
         TypeError: If the dtype of `indices` is not int32 or int64.
         TypeError: If dtype of `input_x` and `updates` are not the same.
         ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `input_x` and `updates` conversion is required when data type conversion
+                      is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2929,7 +3183,7 @@ def sort_ext(input, *, dim=-1, descending=False, stable=False):
         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)).
+        ValueError: If `dim` is not in range of [-len(input.shape), len(input.shape)).
 
     Supported Platforms:
         ``Ascend``
@@ -3414,7 +3668,7 @@ def scatter(input, axis, index, src):
         [0. 0. 0. 0. 0.]]
     """
     if isinstance(src, Tensor):
-        return scatter_(input, axis, index, src)
+        return scatter_prim(input, axis, index, src)
     return scatter_value_(input, axis, index, src)
 
 
@@ -3435,7 +3689,7 @@ def scatter_add_ext(input, dim, index, src):
 
     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``.
+        dim (int): Which dim to scatter. Accepted range is [-r, r) where r = rank(`input`).
         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
@@ -3448,10 +3702,10 @@ def scatter_add_ext(input, dim, index, src):
 
     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 anyone of the rank among `input`, `index` and `src` is 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: The size of any dimension of `index` except the dimension specified by `dim` is
+            greater than the size of the corresponding dimension of `input`.
         ValueError: If the size of any dimension of `src` is less than that of `index`.
 
     Supported Platforms:
@@ -3988,6 +4242,94 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):  # pylint: disable=re
     return matrix_set_diag_v3_op(x, diagonal, k)
 
 
+def meshgrid_ext(*tensors, indexing='ij'):
+    """
+    Generates coordinate matrices from given coordinate tensors.
+
+    Given N one-dimensional coordinate tensors, returns a tuple outputs of N N-D
+    coordinate tensors for evaluating expressions on an N-D grid.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        tensors (Union(tuple[Tensor], list[Tensor])): In GRAPH_MODE, a tuple of N 1-D Tensor objects and
+            the length of input should be greater than 1. In PYNATIVE_MODE, a tuple of N 0-D or 1-D Tensor objects
+            and the length of input should be greater than 0. The data type is Number.
+
+    Keyword Args:
+        indexing (str, optional): Cartesian ('xy', default) or
+            matrix ('ij') indexing of output. Valid options: xy' or ``'ij'``. In the 2-D case with
+            inputs of length `M` and `N`, for ``'xy'`` indexing, the shape of outputs is :math:`(N, M)`
+            for ``'ij'`` indexing, the shape of outputs is :math:`(M, N)`. In the 3-D
+            case with inputs of length `M`, `N` and `P`, for ``'xy'`` indexing, the shape of outputs is
+            :math:`(N, M, P)` and for ``'ij'`` indexing, the shape of outputs is :math:`(M, N, P)`.
+            Default: ``'ij'`` .
+
+    Returns:
+        Tensors, a Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
+
+    Raises:
+        TypeError: If `indexing` is not a str or `tensors` is not a tuple.
+        ValueError: If `indexing` is neither ``'xy'`` nor ``'ij'``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([1, 2, 3, 4]).astype(np.int32))
+        >>> y = Tensor(np.array([5, 6, 7]).astype(np.int32))
+        >>> z = Tensor(np.array([8, 9, 0, 1, 2]).astype(np.int32))
+        >>> output = ops.meshgrid(x, y, z, indexing='xy')
+        >>> print(output)
+        (Tensor(shape=[3, 4, 5], dtype=Int32, value=
+         [[[1, 1, 1, 1, 1],
+           [2, 2, 2, 2, 2],
+           [3, 3, 3, 3, 3],
+           [4, 4, 4, 4, 4]],
+          [[1, 1, 1, 1, 1],
+           [2, 2, 2, 2, 2],
+           [3, 3, 3, 3, 3],
+           [4, 4, 4, 4, 4]],
+          [[1, 1, 1, 1, 1],
+           [2, 2, 2, 2, 2],
+           [3, 3, 3, 3, 3],
+           [4, 4, 4, 4, 4]]]),
+         Tensor(shape=[3, 4, 5], dtype=Int32, value=
+         [[[5, 5, 5, 5, 5],
+           [5, 5, 5, 5, 5],
+           [5, 5, 5, 5, 5],
+           [5, 5, 5, 5, 5]],
+          [[6, 6, 6, 6, 6],
+           [6, 6, 6, 6, 6],
+           [6, 6, 6, 6, 6],
+           [6, 6, 6, 6, 6]],
+          [[7, 7, 7, 7, 7],
+           [7, 7, 7, 7, 7],
+           [7, 7, 7, 7, 7],
+           [7, 7, 7, 7, 7]]]),
+         Tensor(shape=[3, 4, 5], dtype=Int32, value=
+         [[[8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2]],
+          [[8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2]],
+          [[8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2],
+           [8, 9, 0, 1, 2]]]))
+    """
+    if indexing is None:
+        indexing = 'ij'
+    return meshgrid_impl(tensors, indexing)
+
+
 def meshgrid(*inputs, indexing='xy'):
     """
     Generates coordinate matrices from given coordinate tensors.
@@ -3996,8 +4338,9 @@ def meshgrid(*inputs, indexing='xy'):
     coordinate tensors for evaluating expressions on an N-D grid.
 
     Args:
-        inputs (List[Tensor]): List of 1-D tensors.
-            The length of inputs should be greater than 1. The data type is Number.
+        inputs (Union(tuple[Tensor], list[Tensor])): In GRAPH_MODE, a tuple of N 1-D Tensor objects and
+            the length of input should be greater than 1. In PYNATIVE_MODE, a tuple of N 0-D or 1-D Tensor objects
+            and the length of input should be greater than 0. The data type is Number.
 
     Keyword Args:
         indexing (str, optional): Cartesian ('xy', default) or
@@ -4067,7 +4410,7 @@ def meshgrid(*inputs, indexing='xy'):
            [8, 9, 0, 1, 2],
            [8, 9, 0, 1, 2]]]))
     """
-    meshgrid_op = _get_cache_prim(P.Meshgrid)(indexing)
+    meshgrid_op = _get_cache_prim(Meshgrid)(indexing)
     return meshgrid_op(inputs)
 
 
@@ -4314,6 +4657,58 @@ def index_fill(x, axis, index, value):
         value = cast_(value, x.dtype)
     return index_fill_(x, axis, index, value)
 
+def index_fill_ext(input, dim, index, value):
+    """
+    Fills the elements under the `dim` dimension of the input Tensor `input` with the input `value`
+    by selecting the indices in the order given in `index`.
+
+    Args:
+        input (Tensor): Input Tensor.  The supported data type is Number or Bool.
+        dim (int): Dimension along which to fill the input Tensor. Only supports
+            an int number, which data type is int32 or int64.
+        index (Tensor): Indices of the input Tensor to fill in. The dtype must be int32 or int64.
+        value (Union[bool, int, float, Tensor]): Value to fill the returned Tensor. If `value` is
+            a Tensor, it must be a 0-dimensional Tensor and has the same dtype as `input`. Otherwise,
+            the `value` will be a value with the same data type as `input`.
+
+    Returns:
+        Tensor, has the same dtype and shape as input Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is neither int number nor Tensor.
+        TypeError: When `dim` is a Tensor, its dtype is not int32 or int64.
+        TypeError: If `index` is not a Tensor.
+        TypeError: If dtype of `index` is not int32.
+        TypeError: If `value` is not a bool, int, float, or Tensor.
+        TypeError: When `value` is a Tensor, the dtype of `input` and `value` are not the same.
+        ValueError: If `dim` is a Tensor and its rank is not equal to 0.
+        ValueError: If the rank of `index` is greater than 1D.
+        ValueError: When `value` is a Tensor and its rank is not equal to 0.
+        RuntimeError: If the value of `dim` is out the range of `[-x.ndim, x.ndim - 1]`.
+        RuntimeError: If the values of `index` are out the range of `[-x.shape[dim], x.shape[dim]-1]`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> input = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.float32))
+        >>> index = Tensor([0, 2], mindspore.int32)
+        >>> value = Tensor(-2.0, mindspore.float32)
+        >>> y = ops.index_fill_ext(x, 1, index, value)
+        >>> print(y)
+        [[-2. 2. -2.]
+         [-2. 5. -2.]
+         [-2. 8. -2.]]
+    """
+    if isinstance(value, Tensor):
+        return index_fill_tensor(input, dim, index, value)
+    return index_fill_scalar(input, dim, index, value)
+
 
 @constexpr
 def _check_check_axis_in_range(axis, ndim):
@@ -4881,30 +5276,30 @@ def split(tensor, split_size_or_sections, axis=0):
     return tuple(res)
 
 
-def split_ext(tensor, split_size_or_sections, axis=0):
+def split_ext(tensor, split_size, dim=0):
     """
-    Splits the Tensor into chunks along the given axis.
+    Splits the Tensor into chunks along the given dim.
 
     Args:
         tensor (Tensor): A Tensor to be divided.
-        split_size_or_sections (Union[int, tuple(int), list(int)]):
-            If `split_size_or_sections` is an int type, `tensor` will be split into equally sized chunks,
-            each chunk with size `split_size_or_sections`. Last chunk will be smaller than `split_size_or_sections`
-            if `tensor.shape[axis]` is not divisible by `split_size_or_sections`.
-            If `split_size_or_sections` is a list type, then `tensor` will be split into len(split_size_or_sections)
-            chunks with sizes `split_size_or_sections` along the given `axis`.
-        axis (int): The axis along which to split. Default: ``0`` .
+        split_size (Union[int, tuple(int), list(int)]):
+            If `split_size` is an int type, `tensor` will be split into equally sized chunks,
+            each chunk with size `split_size`. Last chunk will be smaller than `split_size`
+            if `tensor.shape[dim]` is not divisible by `split_size`.
+            If `split_size` is a list type, then `tensor` will be split into len(split_size)
+            chunks with sizes `split_size` along the given `dim`.
+        dim (int): The dim along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
 
     Raises:
         TypeError: If argument `tensor` is not Tensor.
-        TypeError: If argument `axis` is not int.
-        ValueError: If argument `axis` is out of range of :[-tensor.ndim, tensor.ndim).
-        TypeError: If each element in `split_size_or_sections` is not integer.
-        TypeError: If argument `split_size_or_sections` is not int, tuple(int) or list(int).
-        ValueError: The sum of `split_size_or_sections` is not equal to x.shape[axis].
+        TypeError: If argument `dim` is not int.
+        ValueError: If argument `dim` is out of range of :[-tensor.ndim, tensor.ndim).
+        TypeError: If each element in `split_size` is not integer.
+        TypeError: If argument `split_size` is not int, tuple(int) or list(int).
+        ValueError: The sum of `split_size` is not equal to x.shape[dim].
 
     Supported Platforms:
         ``Ascend``
@@ -4919,13 +5314,13 @@ def split_ext(tensor, split_size_or_sections, axis=0):
          Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
          Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
     """
-    if isinstance(split_size_or_sections, int):
-        res = split_tensor(tensor, split_size_or_sections, axis)
-    elif isinstance(split_size_or_sections, (list, tuple)):
-        res = split_with_size(tensor, split_size_or_sections, axis)
+    if isinstance(split_size, int):
+        res = split_tensor(tensor, split_size, dim)
+    elif isinstance(split_size, (list, tuple)):
+        res = split_with_size(tensor, split_size, dim)
     else:
-        raise TypeError(f"Type of Argument `split_size_or_sections` should be integer, tuple(int) or list(int), "
-                        f"but got {type(split_size_or_sections)}")
+        raise TypeError(f"Type of Argument `split_size` should be integer, tuple(int) or list(int), "
+                        f"but got {type(split_size)}")
     return res
 
 
@@ -4997,8 +5392,8 @@ def tril_ext(input, diagonal=0):
 
     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,
+            Supporting all number types including bool.
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: ``0``,
             indicating the main diagonal.
 
     Returns:
@@ -5195,7 +5590,7 @@ def tensor_split(input, indices_or_sections, axis=0):
               and :math:`axis=0` , the input tensor will be split into sections :math:`input[:1]` ,
               :math:`input[1:4]` , and :math:`input[4:]` .
 
-        axis (int): The axis along which to split. Default: ``0`` .
+        axis (int, optional): The axis along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -5627,16 +6022,13 @@ def aminmax(input, *, axis=0, keepdims=False):
     argmax_with_value_op = _get_cache_prim(ArgMaxWithValue)(axis, keepdims)
     _, output0 = argmin_with_value_op(input)
     _, output1 = argmax_with_value_op(input)
-    if keepdims is True and input.ndim == 0:
-        output0 = ops.reshape(output0, [1])
-        output1 = ops.reshape(output1, [1])
     return output0, output1
 
 
 def narrow(input, axis, start, length):
     """
-    Returns a narrowed tensor from input tensor, and
-    the dimension axis is input from start to start + length.
+    Obtains a tensor of a specified length at a
+    specified start position along a specified axis.
 
     Args:
         input (Tensor): the tensor to narrow.
@@ -5682,48 +6074,6 @@ def narrow(input, axis, start, length):
     sizes[axis] = 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.
@@ -5795,6 +6145,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
          [3, 0],
          [0, 1]]))
     """
+    validator.check_value_type("largest", largest, [bool], "topk")
     top_k_ = _get_cache_prim(P.TopK)(sorted)
     if not largest:
         input = -input
@@ -5817,8 +6168,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
 def expand(input_x, size):
     r"""
-    :func:`mindspore.ops.expand` will be deprecated in the future.
-    Please use :func:`mindspore.ops.broadcast_to` instead.
+    This interface will be deprecated in the future, and use :func:`mindspore.ops.broadcast_to` instead.
     """
     expand_op = _get_cache_prim(Expand)()
     return expand_op(input_x, size)
@@ -6214,17 +6564,21 @@ def mvlgamma(input, p):
     return mvlgamma_op(input)
 
 
-def nonzero(input, as_tuple=False):
+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.
+        input (Tensor): The input Tensor.
+
+            - Ascend: its rank can be equal to 0 except O2 mode.
+            - CPU/GPU: its rank should be greater than or eaqual to 1.
+
+    Keyword Args:
         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.
@@ -6236,7 +6590,7 @@ def nonzero(input, as_tuple=False):
     Raises:
         TypeError: If `input` is not Tensor.
         TypeError: If `as_tuple` is not bool.
-        ValueError: If dim of `input` equals to 0.
+        RuntimeError: On GPU or CPU or Ascend O2 mode, if dim of `input` equals to 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -6251,22 +6605,25 @@ def nonzero(input, as_tuple=False):
         [[0 0 0]
          [0 1 0]]
         >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
-        >>> output = ops.nonzero(x, False)
+        >>> output = ops.nonzero(x, as_tuple=False)
         >>> print(output)
         [[0]
          [2]
          [4]]
         >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
-        >>> output = ops.nonzero(x, True)
+        >>> output = ops.nonzero(x, as_tuple=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)
+        >>> output = ops.nonzero(x, as_tuple=True)
         >>> print(output)
         (Tensor(shape=[3], dtype=Int64, value=[0, 2, 4]), )
     """
+    if not isinstance(as_tuple, bool):
+        raise TypeError(
+            f"For array function 'nonzero', 'as_tuple' must be bool, but got {type(as_tuple)}.")
     if as_tuple:
         return non_zero_ext_(input)
     return non_zero_(input)
@@ -6651,7 +7008,7 @@ def _check_rank_range(x_rank, limit, arg_name, op_name):
 
 def repeat_interleave(input, repeats, axis=None):
     """
-    Repeat elements of a tensor along an axis, like `numpy.repeat`.
+    Repeat elements of a tensor along an axis, like :func:`mindspore.numpy.repeat`.
 
     Args:
         input (Tensor): The tensor to repeat values for. Must be of type: float16,
@@ -6691,7 +7048,7 @@ def repeat_interleave(input, repeats, axis=None):
 
 def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
     r"""
-    Repeat elements of a tensor along an axis, like `numpy.repeat`.
+    Repeat elements of a tensor along an axis, like :func:`mindspore.numpy.repeat`.
 
     .. warning::
         Only support on Atlas A2 training series.
@@ -6732,7 +7089,7 @@ def repeat_interleave_ext(input, repeats, dim=None, output_size=None):
 
 def repeat_elements(x, rep, axis=0):
     """
-    Repeat elements of a tensor along an axis, like `numpy.repeat` .
+    Repeat elements of a tensor along an axis, like :func:`mindspore.numpy.repeat` .
 
     Note:
         It is recommended to use :func:'mindspore.mint.repeat_interleave', the dimension of input 'x' can support
@@ -6909,10 +7266,9 @@ def gather_ext(input, dim, index):
         >>> 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)
+        >>> output = ops.function.array_func.gather_ext(input, 1, index)
         >>> print(output)
         [[-0.1 -0.1]
          [0.5   0.5]]
@@ -6954,10 +7310,9 @@ def max_ext(input, dim=None, keepdim=False):
         >>> 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)
+        >>> output, index = ops.function.array_func.max_ext(y, 0, True)
         >>> print(output, index)
         [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
     """
@@ -7005,9 +7360,8 @@ def min_ext(input, dim=None, keepdim=False):
         >>> 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)
+        >>> output, index = ops.function.array_func.min_ext(x, 0, keepdim=True)
         >>> print(output, index)
         [0.0] [0]
     """
@@ -7085,6 +7439,51 @@ def from_numpy(array):
     """
     return Tensor.from_numpy(array)
 
+
+def type_as(input, other):
+    r"""
+    Returns input cast to the type of the with the other.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        When converting complex numbers to boolean type, the imaginary part of the complex number is not
+        taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
+
+    Args:
+        input (Tensor): The shape of tensor is :math:`(x_0, x_1, ..., x_R)`.
+            The tensor whose data type is to be converted.
+        other (Tensor): The shape of tensor is :math:`(x_0, x_1, ..., x_R)`.
+            The tensor whose data type is specified.
+
+    Returns:
+        Tensor, the shape of tensor is the same as `input`, :math:`(x_0, x_1, ..., x_R)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `other` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        >>> input = Tensor(input_np)
+        >>> other_np = np.random.randn(2, 3, 4).astype(np.int32)
+        >>> other = Tensor(other_np)
+        >>> output = ops.type_as(input, other)
+        >>> print(output.dtype)
+        Int32
+        >>> print(output.shape)
+        (2, 3, 4, 5)
+    """
+    return type_as_(input, other)
+
+
 __all__ = [
     'unique',
     'unique_with_pad',
@@ -7224,5 +7623,8 @@ __all__ = [
     'top_k',
     'deepcopy',
     'flip',
+    'view_as',
+    'type_as',
+    'expand_as',
 ]
 __all__.sort()