mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/function/array_func.py

@@ -17,12 +17,20 @@
 from __future__ import absolute_import
 
 import builtins
-
+import operator
+import numbers
 import numpy as np
 
+import mindspore as ms
 import mindspore.common.dtype as mstype
 from mindspore.ops import operations as P
 from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
+import mindspore.ops.function as ops
+from mindspore.ops import functional as F
+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.array_ops import (
     UniqueConsecutive,
@@ -43,16 +51,19 @@ from mindspore.ops.operations.array_ops import (
     Expand,
     Lstsq,
     Mvlgamma,
+    Tril,
+    Argmax
 )
 from mindspore.ops.operations.array_ops import TensorScatterElements
 from mindspore.common import Tensor
 from mindspore.ops._primitive_cache import _get_cache_prim
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
+from mindspore._c_expression import Tensor as Tensor_
 
+tuple_to_tensor_ = TupleToTensor()
 eye_ = P.Eye()
-fill_ = P.Fill()
 fills_ = Fills()
+fill_ = P.Fill()
 ones_ = P.Ones()
 ones_like_ = P.OnesLike()
 tile_ = P.Tile()
@@ -95,14 +106,16 @@ tensor_select_ = P.Select()
 index_fill_ = IndexFill()
 unsorted_segment_sum_ = P.UnsortedSegmentSum()
 population_count_ = P.PopulationCount()
+reduce_max = P.ReduceMax()
+reduce_min = P.ReduceMin()
 
 
-@constexpr
+@_primexpr
 def get_x_shape(x_shape):
-    if -1 in x_shape:
-        return (-1,)
-    if -2 in x_shape:
+    if F.is_sequence_shape_unknown(x_shape):
         return (-2,)
+    if F.is_sequence_value_unknown(x_shape):
+        return (-1,)
     s = 1
     for i in x_shape:
         s = s * i
@@ -114,6 +127,9 @@ def _check_attr_dtype(param_name, input_dtype, allow_dtypes, cls_name):
     validator.check_value_type(param_name, input_dtype, allow_dtypes, cls_name)
 
 
+check_flatten_order_const = constexpr(validator.check_flatten_order)
+
+
 ##############################
 # Tensor Creation Functions.
 ##############################
@@ -132,7 +148,7 @@ def _get_type(x):
     """get the dtype of input"""
     if isinstance(x, Tensor):
         return x.dtype
-    return type(x)
+    return F.typeof(x)
 
 
 def _get_max_type(start, end, step):
@@ -161,18 +177,18 @@ def arange(start=0, end=None, step=1, *, dtype=None):
     `step` up to but not including `end`.
 
     Args:
-        start (Union[float, int, Tensor], optional): The first number in the sequence.
+        start (Union[float, int, Tensor], optional): The start of the interval.
             If Tensor, the shape must be (). Default: 0.
-        end (Union[float, int, Tensor], optional): Upper or lower limit of the sequence, exclusive.
+        end (Union[float, int, Tensor], optional): The end of the interval, exclusive.
             If Tensor, the shape must be ().
             Default: None. If None, it defaults to the value of `start`, and 0 is used as the starting value.
         step (Union[float, int, Tensor], optional): Number that increments `start`.
             If Tensor, the shape must be (). Default: 1.
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The desired data type of returned tensor. Default: None.
-            If dtype is not given or None, the dtype is inferred to be the type with the highest precision among
-            the `start`, `end` and `step` parameters.
+        dtype (mindspore.dtype, optional): The required data type of returned Tensor. Default: None.
+            If the value is not specified or is None, the type with the highest precision in the
+            `start`, `end`, and `step` parameters is inferred.
 
     Returns:
         A 1-D Tensor, with the same type as the inputs.
@@ -227,7 +243,60 @@ def arange(start=0, end=None, step=1, *, dtype=None):
     return data
 
 
-def eye(n, m, t):
+def cat(tensors, axis=0):
+    r"""
+    Connect input tensors along with the given axis.
+
+    The input data is a tuple or a list of tensors. These tensors have the same rank :math:`R`.
+    Set the given axis as :math:`m`, and :math:`0 \le m < R`. Set the number of input tensors as :math:`N`.
+    For the :math:`i`-th tensor :math:`t_i`, it has the shape of :math:`(x_1, x_2, ..., x_{mi}, ..., x_R)`.
+    :math:`x_{mi}` is the :math:`m`-th dimension of the :math:`t_i`. Then, the shape of the output tensor is
+
+    .. math::
+
+        (x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)
+
+    Args:
+        tensors (Union[tuple, list]): A tuple or a list of input tensors.
+            Suppose there are two tensors in this tuple or list, namely t1 and t2.
+            To perform `concat` in the axis 0 direction, except for the :math:`0`-th axis,
+            all other dimensions should be equal, that is,
+            :math:`t1.shape[1] = t2.shape[1], t1.shape[2] = t2.shape[2], ..., t1.shape[R-1] = t2.shape[R-1]`,
+            where :math:`R` represents the rank of tensor.
+        axis (int): The specified axis, whose value is in range :math:`[-R, R)`. Default: 0.
+
+    Returns:
+        Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
+            The data type is the same with `tensors`.
+
+    Raises:
+        TypeError: If `axis` is not an int.
+        ValueError: If `tensors` have different dimension of tensor.
+        ValueError: If `axis` not in range :math:`[-R, R)`.
+        RuntimeError: If tensor's shape in `tensors` except for `axis` are different.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
+        >>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
+        >>> output = ops.cat((input_x1, input_x2))
+        >>> print(output)
+        [[0. 1.]
+         [2. 1.]
+         [0. 1.]
+         [2. 1.]]
+        >>> output = ops.cat((input_x1, input_x2), 1)
+        >>> print(output)
+        [[0. 1. 0. 1.]
+         [2. 1. 2. 1.]]
+    """
+    _concat = _get_cache_prim(P.Concat)(axis)
+    return _concat(tensors)
+
+
+def eye(n, m=None, dtype=None):
     """
     Creates a tensor with ones on the diagonal and zeros in the rest.
 
@@ -238,12 +307,14 @@ def eye(n, m, t):
     Args:
         n (int): The number of rows of returned tensor. Constant value only.
         m (int): The number of columns of returned tensor. Constant value only.
-        t (mindspore.dtype): MindSpore's dtype, the data type of the returned tensor.
-            The data type can be Number.
+            Default: if None, the number of columns is as the same as n.
+        dtype (mindspore.dtype): MindSpore's dtype, the data type of the returned tensor.
+            The data type can be bool or Number.
+            Default: None, the data type of the returned tensor is mindspore.float32.
 
     Returns:
         Tensor, a tensor with ones on the diagonal and the rest of elements are zero. The shape of `output` depends on
-        the user's Inputs `n` and `m`. And the data type depends on Inputs `t`.
+        the user's Inputs `n` and `m`. And the data type depends on Inputs `dtype`.
 
     Raises:
         TypeError: If `m` or `n` is not an int.
@@ -264,8 +335,135 @@ def eye(n, m, t):
         [[1. 0.]]
         >>> print(output.dtype)
         Float64
+        >>> output = ops.eye(2, dtype=mindspore.int32)
+        >>> print(output)
+        [[1 0]
+         [0 1]]
+        >>> print(output.dtype)
+        Int32
+        >>> output = ops.eye(2)
+        >>> print(output)
+        [[1. 0.]
+         [0. 1.]]
+        >>> print(output.dtype)
+        Float32
+    """
+    if m is None:
+        m = n
+    if dtype is None:
+        dtype = ms.float32
+    return eye_(n, m, dtype)
+
+
+def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype=None):
+    r"""
+    Returns the Hamming window.
+
+    .. math::
+
+        w[n]=\alpha − \beta \cos \left( \frac{2 \pi n}{N - 1} \right),
+
+    where :math:`N` is the full window size.
+
+    Args:
+        window_length (int): The size of returned window. Must be a non negative integer.
+        periodic (bool, optional): If True, return a periodic window. If False, return a symmetric window.
+        alpha (float, optional): The coefficient α.
+        beta (float, optional): The coefficient β.
+
+    Keyword Args:
+        dtype (mindspore.dtype, optional): The output window data type. Default: None.
+
+    Returns:
+        Tensor, a 1-D tensor of size (window_length) containing the window.
+
+    Raises:
+        TypeError: If `window_length` is a negative integer.
+        TypeError: If `periodic` is not bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> print(ops.hamming_window(6, False))
+        [0.08 0.39785218 0.91214782  0.91214782  0.39785218 0.08]
+    """
+    if not isinstance(window_length, int):
+        raise TypeError(f"For array function 'hamming_window', 'window_length' must be int, but got" \
+            f" {type(window_length)}.")
+    if window_length < 0:
+        raise ValueError(f"For array function 'hamming_window', 'window_length' must be non negative number.")
+    if not isinstance(periodic, bool):
+        raise TypeError(f"For array function 'hamming_window', 'periodic' must be bool, but got {type(periodic)}.")
+    if not isinstance(alpha, float):
+        raise TypeError(f"For array function 'hamming_window', 'alpha' must be float, but got {type(alpha)}.")
+    if not isinstance(beta, float):
+        raise TypeError(f"For array function 'hamming_window', 'beta' must be float, but got {type(beta)}.")
+    if window_length <= 1:
+        return Tensor(np.ones(window_length))
+    if dtype is not None and dtype not in mstype.float_type:
+        raise TypeError(f"For array function 'hamming_window', 'dtype' must be floating point dtypes, but got {dtype}.")
+
+    if periodic:
+        window_length += 1
+    n = arange(0, window_length)
+    w = alpha - beta * ops.cos((2 * np.pi / (window_length - 1)) * n)
+
+    if dtype is not None:
+        w = P.Cast()(w, dtype)
+    return w[:-1] if periodic else w
+
+
+def where(condition, x, y):
+    r"""
+    Selects elements from `x` or `y` based on `condition` and returns a tensor.
+
+    .. math::
+        output_i = \begin{cases} x_i,\quad &if\ condition_i \\ y_i,\quad &otherwise \end{cases}
+
+    Args:
+        condition (Tensor[bool]): If True, yield `x`, otherwise yield `y`.
+        x (Union[Tensor, Scalar]): When `condition` is True, values to select from.
+        y (Union[Tensor, Scalar]): When `condition` is False, values to select from.
+
+    Returns:
+        Tensor, elements are selected from `x` and `y`.
+
+    Raises:
+        TypeError: If `condition` is not a Tensor.
+        TypeError: If both `x` and `y` are scalars.
+        ValueError: If `condition`, `x` and `y` can not broadcast to each other.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> a = Tensor(np.arange(4).reshape((2, 2)), mstype.float32)
+        >>> b = Tensor(np.ones((2, 2)), mstype.float32)
+        >>> condition = a < 3
+        >>> output = ops.where(condition, a, b)
+        >>> print(output)
+        [[0. 1.]
+         [2. 1.]]
     """
-    return eye_(n, m, t)
+    if not isinstance(condition, Tensor):
+        raise TypeError(f"For 'where', 'condition' must be a Tensor, but got {type(condition)}.")
+    if isinstance(x, (int, float)):
+        if not isinstance(y, Tensor):
+            raise TypeError(f"For 'where', at least one of 'x' and 'y' should be Tensor, \
+            but got x:{type(x)}, y:{type(y)}.")
+        x = cast_(x, y.dtype)
+    elif isinstance(y, (int, float)):
+        if not isinstance(x, Tensor):
+            raise TypeError(f"For 'where', at least one of 'x' and 'y' should be Tensor, \
+            but got x:{type(x)}, y:{type(y)}.")
+        y = cast_(y, x.dtype)
+    output_shape = _calc_broadcast_shape(x.shape, y.shape, condition.shape)
+    condition = broadcast_to(condition, output_shape)
+    x = broadcast_to(x, output_shape)
+    y = broadcast_to(y, output_shape)
+    _select = P.Select()
+    return _select(condition, x, y)
 
 
 def reverse(x, axis):
@@ -277,10 +475,10 @@ def reverse(x, axis):
 
     Args:
         x (Tensor): The target tensor. The data type is Number except float64.
-            The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+            The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         axis (Union[tuple(int), list(int)]): The indices of the dimensions to reverse.
 
-    Returns:
+    Outputs:
         Tensor, has the same shape and type as `x`.
 
     Raises:
@@ -305,6 +503,33 @@ def reverse(x, axis):
     return P.ReverseV2(axis)(x)
 
 
+def ravel(input):
+    """
+    Expand the multidimensional Tensor into 1D along the 0 axis direction.
+
+    Args:
+        input (Tensor): A tensor to be flattened.
+
+    Returns:
+        Tensor, a 1-D tensor, containing the same elements of the input.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
+        >>> output = ops.ravel(x)
+        >>> print(output)
+        [0. 1. 2. 1.]
+        >>> print(output.shape)
+        (4,)
+    """
+    return ops.reshape(input, (-1,))
+
+
 def matrix_band_part(x, lower, upper):
     r"""
     Copy a tensor setting everything outside a central band in each innermost matrix to zero.
@@ -332,7 +557,7 @@ def matrix_band_part(x, lower, upper):
         ValueError: If the shape of `upper` is not equal to 0D.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+
 
     Examples:
         >>> x = Tensor(np.ones([2, 4, 4]).astype(np.float32))
@@ -382,6 +607,27 @@ def padding(x, pad_dim_size=8):
     return padding_(x)
 
 
+@constexpr
+def _check_axis_type(axis, type_int=True, type_tuple=True, type_list=True, ops_name="ops"):
+    """Check axis argument type."""
+    if type_int and isinstance(axis, int):
+        return True
+    if (type_tuple and isinstance(axis, tuple)) or (type_list and isinstance(axis, list)):
+        for ax in axis:
+            if not isinstance(ax, int):
+                raise TypeError(f"For {ops_name}, each axis must be integer, but got {type(ax)} in {axis}.")
+        return True
+
+    type_str = ""
+    if type_int:
+        type_str += "int, "
+    if type_tuple:
+        type_str += "tuple, "
+    if type_list:
+        type_str += "list, "
+    raise TypeError(f"For {ops_name}, the axis should be {type_str}, but got {type(axis)}.")
+
+
 def one_hot(indices, depth, on_value, off_value, axis=-1):
     r"""
     Computes a one-hot tensor.
@@ -396,13 +642,14 @@ def one_hot(indices, depth, on_value, off_value, axis=-1):
         indices(Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
             Data type must be uint8, int32 or int64.
         depth(int): A scalar defining the depth of the one-hot dimension.
-        on_value(Tensor): A value to fill in output when `indices[j] = i`.
+        on_value(Union[Tensor, int, float]): A value to fill in output when `indices[j] = i`.
             Support uint8, uint16, uint32, uint64, int8, int16, int32, int64, float16, float32, float64,
             bool, complex64, complex128.
-        off_value(Tensor): A value to fill in output when `indices[j] != i`.
+        off_value(Union[Tensor, int, float]): A value to fill in output when `indices[j] != i`.
             Has the same data type as `on_value`.
         axis(int): Position to insert the value. e.g. If shape of `self` is :math:`(N, C)`, and `axis` is -1,
-            the output shape will be :math:`(N, C, D)`, If `axis` is 0, the output shape will be :math:`(D, N, C)`.
+            the output shape will be :math:`(N, C, depth)`, If `axis` is 0,
+            the output shape will be :math:`(depth, N, C)`.
             Default: -1.
 
     Returns:
@@ -427,26 +674,30 @@ def one_hot(indices, depth, on_value, off_value, axis=-1):
          [0. 1. 0.]
          [0. 0. 1.]]
     """
+    if not isinstance(on_value, Tensor):
+        on_value = Tensor(on_value)
+    if not isinstance(off_value, Tensor):
+        off_value = Tensor(off_value)
     onehot = _get_cache_prim(P.OneHot)(axis)
     return onehot(indices, depth, on_value, off_value)
 
 
-def fill(type, shape, value):
+def fill(type, shape, value):  # pylint: disable=redefined-outer-name
     """
     Create a Tensor of the specified shape and fill it with the specified value.
 
     Args:
         type (mindspore.dtype): The specified type of output tensor. The data type only supports
-            `bool_ <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/mindspore.html#mindspore.dtype>`_ and
-            `number <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/mindspore.html#mindspore.dtype>`_ .
-        shape (tuple[int]): The specified shape of output tensor.
-        value (Union(number.Number, bool)): Value to fill the returned tensor.
+            `bool_ <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ and
+            `number <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ .
+        shape (Union(Tensor, tuple[int])): The specified shape of output tensor.
+        value (Union(Tensor, number.Number, bool)): Value to fill the returned tensor.
 
     Returns:
         Tensor.
 
     Raises:
-        TypeError: If `shape` is not a tuple.
+        TypeError: If `shape` is not a tuple or a tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -465,36 +716,159 @@ def fill(type, shape, value):
     return fill_(type, shape, value)
 
 
-def fills(x, value):
+def full(size, fill_value, *, dtype=None): # pylint: disable=redefined-outer-name
+    """
+    Create a Tensor of the specified shape and fill it with the specified value.
+
+    Args:
+        size (Union(tuple[int], list[int])): The specified shape of output tensor.
+        fill_value (number.Number): Value to fill the returned tensor. Complex numbers are not supported for now.
+
+    Keyword Args:
+        dtype (mindspore.dtype): The specified type of output tensor. `bool_` and `number` are supported, for details,
+            please refer to :class:`mindspore.dtype` . Default: None.
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `size` is not a tuple or list.
+        ValueError: The element in `size` is less than 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> output = ops.full((2, 2), 1)
+        >>> print(output)
+        [[1. 1.]
+         [1. 1.]]
+        >>> output = ops.full((3, 3), 0)
+        >>> print(output)
+        [[0. 0. 0.]
+         [0. 0. 0.]
+         [0. 0. 0.]]
+    """
+    if not isinstance(size, (list, tuple)):
+        raise TypeError(f"For 'ops.full', 'size' must be a tuple or list of ints, but got {type(size)}.")
+    if dtype is None:
+        dtype = mstype.int64
+    if dtype not in mstype.all_types:
+        raise TypeError(f"For 'ops.full', 'dtype' must be mindspore.type, but got {dtype}.")
+    if isinstance(size, list):
+        size = tuple(size)
+    return fill_(dtype, size, fill_value)
+
+
+def full_like(input, fill_value, *, dtype=None):
     """
-    Create a tensor of the same shape and type as the input tensor and fill it with specified value.
+    Return a Tensor of the same shape as `input` and filled with `fill_value`.
 
     Args:
-        x (Tensor): Input tensor, used to specify the shape and type of the output tensor. The data type should be
-            int8, int16, int32, float16 or float32.
-        value (Union[int, float, Tensor]): All elements of the output tensor will be assigned this value. The
-            type should be int, float or 0-dimensional tensor.
+        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, with the same shape and type as input tensor.
+        Tensor.
 
     Raises:
-        TypeError: If `x` is not a tensor.
-        TypeError: If `value` has types not specified above.
-        RuntimeError: If `value` cannot be converted to the same type as `x`.
-        ValueError: If `value` is a tensor and the length of dimension is not 0.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> x = Tensor(np.arange(4).reshape((2, 2)).astype('float32'))
-        >>> output = ops.fills(x, 1)
+        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
+        >>> output = ops.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 = ops.full_like(input, 0)
+        >>> print(output)
+        [[0. 0. 0.]
+         [0. 0. 0.]
+         [0. 0. 0.]]
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For ops.full_like, the argument 'x' must be tensor, but got {type(input)}")
+    if dtype is None:
+        dtype = input.dtype
+    return full(input.shape, fill_value, dtype=dtype)
+
+
+def chunk(input, chunks, axis=0):
+    """
+    Cut the input Tensor into `chunks` sub-tensors along the specified axis.
+
+    Note:
+        This function may return less then the specified number of chunks!
+
+    Args:
+        input (Tensor): A Tensor to be cut.
+        chunks (int): Number of sub-tensors to cut.
+        axis (int, optional): Specify the dimensions that you want to split. Default: 0.
+
+    Returns:
+        A tuple of sub-tensors.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: The sum of `chunks` is not int.
+        TypeError: If argument `axis` is not int.
+        ValueError: If argument `axis` is out of range of :math:`[-input.ndim, input.ndim)` .
+        ValueError: If argument `chunks` is not positive number.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(9).astype("float32")
+        >>> output = ops.chunk(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[3], dtype=Float32, value= [ 0.00000000e+00,  1.00000000e+00,  2.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
+         Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'For ops.chunk parameter `input` must be Tensor, but got {type(input)}')
+    _check_axis_type(axis, True, False, False, "ops.chunk")
+    arr_axis = _canonicalize_axis(axis, input.ndim)
+
+    if not isinstance(chunks, int):
+        raise TypeError(f"For ops.chunk type of argument `chunks` should be integer, but got {type(chunks)}")
+    if chunks <= 0:
+        raise ValueError(f"For ops.chunk parameter 'chunks' must be greater than 0, but got {chunks}")
+
+    arr_shape = input.shape
+    length_along_dim = arr_shape[arr_axis]
+
+    if chunks > length_along_dim:
+        res = P.Split(arr_axis, length_along_dim)(input)
+    elif length_along_dim % chunks == 0:
+        res = P.Split(arr_axis, chunks)(input)
+    else:
+        block_size = int(np.ceil(length_along_dim / chunks))
+        true_chunks = int(length_along_dim // block_size)
+        length1 = true_chunks * block_size
+        length2 = length_along_dim - length1
+        start1 = _list_comprehensions(rank(input), 0, True)
+        size1 = _tuple_setitem(arr_shape, arr_axis, length1)
+        start2 = _tuple_setitem(start1, arr_axis, length1)
+        size2 = _tuple_setitem(arr_shape, arr_axis, length2)
+        res = P.Split(arr_axis, true_chunks)(tensor_slice(input, start1, size1))
+        if length2:
+            res += P.Split(arr_axis, 1)(tensor_slice(input, start2, size2))
+    return res
+
+
+def fills(x, value):
+    """
+    `fills` is deprecated, please use `ops.fill` instead.
     """
     if isinstance(value, float):
         value_ = value
@@ -511,16 +885,17 @@ def fills(x, value):
     return fills_(x, value_)
 
 
-def ones(shape, type):
+def ones(shape, dtype=None):  # pylint: disable=redefined-outer-name
     r"""
     Creates a tensor filled with value ones.
 
-    Creates a tensor with shape described by the first argument and
-    fills it with value ones in type of the second argument.
+    Creates a tensor with shape described by the first argument and fills it with value ones in type of the second
+    argument.
 
     Args:
         shape (Union[tuple[int], int]): The specified shape of output tensor. Only constant positive int is allowed.
-        type (mindspore.dtype): The specified type of output tensor. Only constant value is allowed.
+        dtype (:class:`mindspore.dtype`): The specified type of output tensor. If `dtype` is None,
+            `mindspore.float32` will be used. Default: None.
 
     Returns:
         Tensor, has the same type and shape as input shape value.
@@ -536,71 +911,162 @@ def ones(shape, type):
         >>> print(output)
         [[1. 1.]
          [1. 1.]]
-        >>> output = ops.ones((3, 3), mindspore.float32)
-        >>> print(output)
-        [[1. 1. 1.]
-         [1. 1. 1.]
-         [1. 1. 1.]]
     """
-    return ones_(shape, type)
+    _dtype = mstype.float32 if dtype is None else dtype
+    ones_op = P.FillV2()
+    value = Tensor(1, _dtype)
+    if isinstance(shape, int):
+        shape = tuple([shape])
+    shape_tensor = shape
+    if isinstance(shape, (list, tuple)) and not shape:
+        shape_tensor = Tensor(shape, dtype=mstype.int64)
+    elif not isinstance(shape, Tensor):
+        shape_tensor = Tensor(shape)
+    if shape_tensor.ndim == 0 and shape_tensor.size == 1:
+        shape_tensor = shape_tensor.reshape(1)
+    output = ones_op(shape_tensor, value)
+    return output
 
 
-def ones_like(input_x):
+def ones_like(input, *, dtype=None):
     """
-    Returns a Tensor with a value of 1 and its shape and data type is the same as the input.
+    Returns a Tensor with a value of 1 and its shape is the same as the input.
 
     Args:
-        input_x (Tensor): Tensor of any dimension.
+        input (Tensor): Tensor of any dimension.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype` is None,
+            the dtype of the input tensor will be used. Default: None.
 
     Returns:
-        Tensor, has the same shape and type as `input_x` but filled with ones.
+        Tensor, has the same shape as `input` but filled with ones.
 
     Raises:
-        TypeError: If `input_x` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-        >>> output = ops.ones_like(input_x)
+        >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
+        >>> output = ops.ones_like(x)
         >>> print(output)
         [[1 1]
          [1 1]]
     """
-    return ones_like_(input_x)
+    ones_like_op = P.OnesLike()
+    output = ones_like_op(input)
+    _dtype = input.dtype if dtype is None else dtype
+    output = cast_(output, _dtype)
+    return output
+
+
+def zeros(size, dtype=None):  # pylint: disable=redefined-outer-name
+    r"""
+    Creates a tensor filled with 0 with shape described by `shape` and fills it with value 0 in type of `dtype`.
+
+    Args:
+        size (Union[tuple[int], int]): The specified shape of output tensor. Only constant positive int is allowed.
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is None,
+            mindspore.float32 will be used. Default: None.
+
+    Returns:
+        Tensor, has the same dtype and size as input.
+
+    Raises:
+        TypeError: If `size` is neither a tuple of int nor an int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> output = ops.zeros((2, 2), mindspore.float32)
+        >>> print(output)
+        [[0. 0.]
+         [0. 0.]]
+    """
+    zero_op = P.FillV2()
+    _dtype = mstype.float32 if dtype is None else dtype
+    value = Tensor(0, _dtype)
+    if isinstance(size, int):
+        size = tuple([size])
+    shape_tensor = size
+    if isinstance(size, (list, tuple)) and not size:
+        shape_tensor = Tensor(size, dtype=mstype.int64)
+    elif not isinstance(size, Tensor):
+        shape_tensor = Tensor(size, dtype=mstype.int64)
+    if shape_tensor.ndim == 0 and shape_tensor.size == 1:
+        shape_tensor = shape_tensor.reshape(1)
+    output = zero_op(shape_tensor, value)
+    return output
+
+
+def zeros_like(input, *, dtype=None):
+    r"""
+    Creates a tensor filled with 0, with the same size as x, and the given dtype.
+
+    If `dtype = None`, the tensor will have the same dtype as input `input`.
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype` is None,
+            the dtype of the input tensor will be used. Default: None.
+
+    Returns:
+        Tensor, filled with 0.
+
+    Raises:
+        TypeError: If dtype is not a MindSpore dtype.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.arange(4).reshape(2, 2))
+        >>> output = ops.zeros_like(x, dtype=mindspore.float32)
+        >>> print(output)
+        [[0. 0.]
+         [0. 0.]]
+    """
+    _dtype = input.dtype if dtype is None else dtype
+    zeros_like_op = P.ZerosLike()
+    output = zeros_like_op(input)
+    output = cast_(output, _dtype)
+    return output
 
 
-def tile(input_x, multiples):
+def tile(input, multiples):
     r"""
     Replicates an input tensor with given multiples times.
 
-    Creates a new tensor by replicating `input_x` `multiples` times. The i'th dimension of
-    output tensor has `input_x.shape[i] * multiples[i]` elements, and the values of `input_x`
+    Creates a new tensor by replicating `input` `multiples` times. The i'th dimension of
+    output tensor has `input.shape[i] * multiples[i]` elements, and the values of `input`
     are replicated `multiples[i]` times along the i'th dimension.
 
     Note:
-        The length of `multiples` must be greater or equal to the length of dimension in `input_x`.
+        The length of `multiples` must be greater or equal to the length of dimension in `input`.
 
     Args:
-        input_x (Tensor): 1-D or higher dimensional Tensor. Set the shape of input tensor as
+        input (Tensor): 1-D or higher dimensional Tensor. Set the shape of input tensor as
             :math:`(x_1, x_2, ..., x_S)` .
-
         multiples (tuple[int]): The parameter that specifies the number of replications,
             the parameter type is tuple, and the data type is int, i.e., :math:`(y_1, y_2, ..., y_S)`.
-            The length of `multiples` cannot be smaller than the length of the shape of `input_x`.
+            The length of `multiples` cannot be smaller than the length of the shape of `input`.
             Only constant value is allowed.
 
     Returns:
-        Tensor, has the same data type as the `input_x`. Suppose the length of `multiples` is `d`,
-        the dimension of `input_x` is `input_x.dim`, and the shape of `input_x` is :math:`(x_1, x_2, ..., x_S)`.
+        Tensor, has the same data type as the `input`. Suppose the length of `multiples` is `d`,
+        the dimension of `input` is `input.dim`, and the shape of `input` is :math:`(x_1, x_2, ..., x_S)`.
 
-        - If `input_x.dim = d`, then the shape of their corresponding positions can be multiplied, and
+        - If `input.dim = d`, then the shape of their corresponding positions can be multiplied, and
           the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_R)`.
-        - If `input_x.dim < d`, fill in multiple 1 in the length of the shape of `input_x` until their
-          lengths are consistent. Such as set the shape of `input_x` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
+        - If `input.dim < d`, fill in multiple 1 in the length of the shape of `input` until their
+          lengths are consistent. Such as set the shape of `input` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
           then the shape of their corresponding positions can be multiplied, and the shape of Outputs is
-          :math:`(1*y_1, ..., x_S*y_R)`.
+          :math:`(1*y_1, ..., x_R*y_R, x_S*y_S)`.
 
     Raises:
         TypeError: If `multiples` is not a tuple or its elements are not all int.
@@ -635,13 +1101,13 @@ def tile(input_x, multiples):
           [1. 2. 1. 2.]
           [3. 4. 3. 4.]]]
     """
-    return tile_(input_x, multiples)
+    return tile_(input, multiples)
 
 
-def range(start, limit, delta):
+def range(start, end, step):
     r"""
     Creates a sequence of numbers that begins at `start` and extends by increments of
-    `delta` up to but not including `limit`.
+    `limit` up to but not including `end`.
 
     The types of all 3 inputs must be the same. The type of the resulting tensor is
     the same as the type of the inputs.
@@ -649,34 +1115,34 @@ def range(start, limit, delta):
     Args:
         start (Tensor): A scalar Tensor. The first number in the sequence. Must have
           type: int32 ,int64, float32 or float64.
-        limit (Tensor): A scalar Tensor. Upper limit of the sequence, exclusive. Must
+        end (Tensor): A scalar Tensor. Upper limit of the sequence, exclusive. Must
           have type: int32 ,int64, float32 or float64.
-        delta (Tensor): A scalar Tensor. Number that increments `start`. Must have
+        step (Tensor): A scalar Tensor. Number that increments `start`. Must have
           type: int32 ,int64, float32 or float64.
 
     Returns:
         A 1-D Tensor, with the same type as the inputs.
 
     Raises:
-        TypeError: If `start`, `limit` or `delta` is not scalar Tensor.
-        TypeError: If datatype of `start`, `limit` or `delta` is not same.
-        TypeError: If datatype of `start`, `limit` or `delta` is not supported.
-        ValueError: If `delta` = 0.
-        ValueError: If `start` >= `limit` when `delta` > 0.
-        ValueError: If `start` <= `limit` when `delta` < 0.
+        TypeError: If `start`, `end` or `step` is not scalar Tensor.
+        TypeError: If datatype of `start`, `end` or `step` is not same.
+        TypeError: If datatype of `start`, `end` or `step` is not supported.
+        ValueError: If `step` = 0.
+        ValueError: If `start` >= `end` when `step` > 0.
+        ValueError: If `start` <= `end` when `step` < 0.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> start = Tensor(0, mstype.int32)
-        >>> limit = Tensor(10, mstype.int32)
-        >>> delta = Tensor(4, mstype.int32)
-        >>> output = ops.range(start, limit, delta)
+        >>> end = Tensor(10, mstype.int32)
+        >>> step = Tensor(4, mstype.int32)
+        >>> output = ops.range(start, end, step)
         >>> print(output)
         [0 4 8]
     """
-    return range_(start, limit, delta)
+    return range_(start, end, step)
 
 
 ##############################
@@ -684,7 +1150,7 @@ def range(start, limit, delta):
 ##############################
 
 
-def unique(x):
+def unique(input):
     """
     Returns the unique elements of input tensor and also return a tensor containing the index of each value of input
     tensor corresponding to the output unique tensor.
@@ -696,20 +1162,20 @@ def unique(x):
     To get the same shape between `idx` and `y`, please ref to :class:'mindspore.ops.UniqueWithPad' operator.
 
     Args:
-        x (Tensor): The input tensor.
+        input (Tensor): The input tensor.
             The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Returns:
         Tuple, containing Tensor objects (`y`, `idx`), `y` is a tensor with the
-        same type as `x`, and contains the unique elements in `x`.
+        same type as `input`, and contains the unique elements in `input`.
         `idx` is a tensor containing indices of elements in
-        the input corresponding to the output tensor, have the same shape with `x`.
+        the input corresponding to the output tensor, have the same shape with `input`.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -734,10 +1200,10 @@ def unique(x):
     unique_op = _get_cache_prim(P.Unique)()
     reshape_op = _get_cache_prim(P.Reshape)()
 
-    shape_x = x.shape
+    shape_x = input.shape
     length_x = get_x_shape(shape_x)
-    x = reshape_op(x, length_x)
-    y, idx = unique_op(x)
+    input = reshape_op(input, length_x)
+    y, idx = unique_op(input)
     idx = reshape_op(idx, shape_x)
     return y, idx
 
@@ -789,38 +1255,38 @@ def unique_with_pad(x, pad_num):
     return unique_with_pad_(x, pad_num)
 
 
-def unique_consecutive(x, return_idx=False, return_counts=False, axis=None):
+def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
     """
     Returns the elements that are unique in each consecutive group of equivalent elements in the input tensor.
 
     Args:
-        x (Tensor): The input tensor.
-        return_idx (bool, optional): Whether to return the indices of the end position of each element in the
-            original input list in the returned unique list. Default: False.
+        input (Tensor): The input tensor.
+        return_idx (bool, optional): Whether to return the index of where the element in the original input
+            maps to the position in the output. Default: False.
         return_counts (bool, optional): Whether to return the counts of each unique element. Default: False.
         axis (int, optional): The dimension to apply unique. If None, the unique of the flattened input is
             returned. If specified, it must be int32 or int64. Default: None.
 
     Returns:
         A tensor or a tuple of tensors containing tensor objects (`output`, `idx`, `counts`). `output` has the
-        same type as `x` and is used to represent the output list of unique scalar elements. If `return_idx` is
-        True, there will be an additional returned tensor, `idx`, which has the same shape as `x` and represents
+        same type as `input` and is used to represent the output list of unique scalar elements. If `return_idx` is
+        True, there will be an additional returned tensor, `idx`, which has the same shape as `input` and represents
         the index of where the element in the original input maps to the position in the output. If `return_counts`
         is True, there will be an additional returned tensor, `counts`, which represents the number of occurrences
         for each unique value or tensor.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
-        RuntimeError: If `axis` is not in the range of :math:`[-ndim, ndim-1]`.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not supported.
+        TypeError: If `return_idx` is not a bool.
+        TypeError: If `return_counts` is not a bool.
+        TypeError: If `axis` is not an int.
+        ValueError: If `axis` is not in the range of :math:`[-ndim, ndim-1]`.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
         >>> x = Tensor(np.array([1, 1, 2, 2, 3, 1, 1, 2]), mstype.int32)
         >>> output, idx, counts = ops.unique_consecutive(x, True, True, None)
         >>> print(output)
@@ -830,8 +1296,11 @@ def unique_consecutive(x, return_idx=False, return_counts=False, axis=None):
         >>> print(counts)
         [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(x)
+    output, idx, counts = unique_consecutive_op(input)
     if return_idx and return_counts:
         return output, idx, counts
     if return_idx:
@@ -843,35 +1312,36 @@ def unique_consecutive(x, return_idx=False, return_counts=False, axis=None):
 
 def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
     """
-    Find the indices from the innermost dimension of `sorted_sequence` such that the order of the innermost dimension
-    within `sorted_sequence` would be preserved when the corresponding values in `values` were inserted before the
-    indices.
+    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.
 
     Args:
-        sorted_sequence (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R-1, x_R)` or `(x_1)`.
+        sorted_sequence (Tensor): The input tensor.
             It must contain a monotonically increasing sequence on the innermost dimension.
-        values (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R-1, x_S)`.
+        values (Tensor): The value that should be inserted.
+
+    Keyword Args:
         out_int32 (bool, optional): Output datatype. If True, the output datatype will be int32;
             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.
 
     Returns:
-        Tensor containing the indices from the innermost dimension of the input sequence such that,
-        if insert the corresponding value in the values tensor, the order of the tensor sequence would be preserved,
-        whose datatype is int32 if out_int32 is True, otherwise int64, and shape is the same as the shape of values.
+        Tensor containing the indices from the innermost dimension of `sorted_sequence` such that,
+        if insert the corresponding value in the `values` tensor, the order of `sorted_sequence` would be preserved,
+        whose datatype is int32 if out_int32 is True, otherwise int64, and shape is the same as the shape of `values`.
 
     Raises:
         ValueError: If the dimension of `sorted_sequence` isn't 1 and all dimensions except the last dimension of
             `sorted_sequence` and `values` are different.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> sorted_sequence = Tensor(np.array([[0, 1, 3, 5, 7], [2, 4, 6, 8, 10]]), mindspore.float32)
         >>> values = Tensor(np.array([[3, 6, 9], [3, 6, 9]]), mindspore.float32)
-        >>> output = ops.SearchSorted()(sorted_sequence, values)
+        >>> output = ops.searchsorted(sorted_sequence, values)
         >>> print(output)
         [[2 4 5]
          [1 2 4]]
@@ -883,42 +1353,42 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
     return search_sorted_(sorted_sequence, values)
 
 
-def ger(x1, x2):
+def ger(input, vec2):
     r"""
-    Ger product of `x1` and `x2`. Calculate the outer product of two arrays. If `x1` is a 1D Tensor of
-    shape :math:`(m,)` and `x2` is a 1D Tensor of shape :math:`(n,)`, then `output` must be a 2D Tensor of shape
+    Ger product of `input` and `vec2`. Calculate the outer product of two arrays. If `input` is a 1D Tensor of
+    shape :math:`(m,)` and `vec2` is a 1D Tensor of shape :math:`(n,)`, then `output` must be a 2D Tensor of shape
     :math:`(m, n)`.
 
     Note:
         Currently Ascend does not support float64 data input.
 
     Args:
-        x1 (Tensor): input Tensor, with dtype of float16, float32 or float64.
-        x2 (Tensor): input Tensor, with dtype of float16, float32 or float64, must have the same dtype as `x1`.
+        input (Tensor): input Tensor, with dtype of float16, float32 or float64.
+        vec2 (Tensor): input Tensor, with dtype of float16, float32 or float64, must have the same dtype as `input`.
 
     Returns:
-        Tensor, output matrix with the same dtype as inputs. With `x1` shape :math:`(m,)` and
-        `x2` shape of :math:`(n,)`, the `output` has shape :math:`(m, n)`.
+        Tensor, output matrix with the same dtype as inputs. With `input` shape :math:`(m,)` and
+        `vec2` shape of :math:`(n,)`, the `output` has shape :math:`(m, n)`.
 
     Raises:
-        TypeError: If `x1` or `x2` is not a 1-D Tensor.
-        TypeError: If the dtype of `x1` and `x2` is not float16, float32 or float64.
-        TypeError: If the dtype of `x1` and `x2` are not the same.
+        TypeError: If `input` or `vec2` is not a 1-D Tensor.
+        TypeError: If the dtype of `input` and `vec2` is not float16, float32 or float64.
+        TypeError: If the dtype of `input` and `vec2` are not the same.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x1 = Tensor([1., 2., 3., 4.], mindspore.float32)
-        >>> x2 = Tensor([1., 2., 3.], mindspore.float32)
-        >>> output = ops.ger(x1, x2)
+        >>> input = Tensor([1., 2., 3., 4.], mindspore.float32)
+        >>> vec2 = Tensor([1., 2., 3.], mindspore.float32)
+        >>> output = ops.ger(input, vec2)
         >>> print(output)
         [[ 1.  2.  3.]
          [ 2.  4.  6.]
          [ 3.  6.  9.]
          [ 4.  8. 12.]]
     """
-    return ger_(x1, x2)
+    return ger_(input, vec2)
 
 
 def size(input_x):
@@ -928,7 +1398,7 @@ def size(input_x):
 
     Args:
         input_x (Tensor): Input parameters, the shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is
-            `number <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -951,11 +1421,7 @@ def size(input_x):
 
 def shape(input_x):
     """
-    Returns the shape of the input tensor. This operation is used in static shape cases.
-
-    static shape: A shape that can be obtained without running the graph. It is an inherent property of tensor and
-    may be unknown. The static shape information can be completed by artificial setting.
-    No matter what the input of the graph is, the static shape is not affected.
+    Returns the shape of the input tensor.
 
     Args:
         input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
@@ -984,10 +1450,10 @@ def dyn_shape(input_x):
     Returns the shape of the input tensor.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        input_x (Tensor): The input Tensor.
 
     Returns:
-        Tensor[int], 1-dim Tensor of type int32
+        Tensor, the shape of `input_x` .
 
     Raises:
         TypeError: If `input_x` is not a Tensor.
@@ -1034,16 +1500,16 @@ def rank(input_x):
     return rank_(input_x)
 
 
-def reshape(input_x, input_shape):
+def reshape(input, shape):
     """
     Rearranges the input Tensor based on the given shape.
 
-    The 'input_shape' can only have one -1 at most, in which case it’s inferred from the remaining dimensions and
+    The 'shape' can only have one -1 at most, in which case it’s inferred from the remaining dimensions and
     the number of elements in the input.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        input_shape (Union[tuple[int], Tensor[int]]): Constructed by multiple
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        shape (Union[tuple[int], Tensor[int]]): Constructed by multiple
             integers, i.e., :math:`(y_1, y_2, ..., y_S)`. Only constant value is allowed.
 
     Returns:
@@ -1058,14 +1524,14 @@ def reshape(input_x, input_shape):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> output = ops.reshape(input_x, (3, 2))
+        >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
+        >>> output = ops.reshape(input, (3, 2))
         >>> print(output)
         [[-0.1  0.3]
          [ 3.6  0.4]
          [ 0.5 -3.2]]
     """
-    return reshape_(input_x, input_shape)
+    return reshape_(input, shape)
 
 
 def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
@@ -1127,20 +1593,30 @@ def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
     return P.ReverseSequence(seq_dim=seq_dim, batch_dim=batch_dim)(x, seq_lengths)
 
 
-def flatten(input_x):
+def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     r"""
-    Flattens a tensor without changing its batch size on the 0-th axis.
+    Flatten a tensor along dimensions from `start_dim` to `start_dim`.
 
     Args:
-        input_x (Tensor): Tensor of shape :math:`(N, \ldots)` to be flattened, where :math:`N` is batch size.
+        input (Tensor): The input Tensor.
+        order (str, optional): Only 'C' and 'F' are supported. 'C' means to flatten in row-major (C-style) order.
+            'F' means to flatten in column-major (Fortran-style) order. Default: 'C'.
+
+    Keyword Args:
+        start_dim (int, optional): The first dimension to flatten. Default: 1.
+        end_dim (int, optional): The last dimension to flatten. Default: -1.
 
     Returns:
-        Tensor, the shape of the output tensor is :math:`(N, X)`, where :math:`X` is
-        the product of the remaining dimension.
+        Tensor. If no dimensions are flattened, returns the original `input`, otherwise return the flattened Tensor.
+        If `input` is a 0-dimensional Tensor, a 1-dimensional Tensor will be returned.
 
     Raises:
-        TypeError: If `input_x` is not a Tensor.
-        ValueError: If length of shape of `input_x` is less than 1.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `order` is not string type.
+        ValueError: If `order` is string type, but not 'C' or 'F'.
+        TypeError: If `start_dim` or `end_dim` is not int.
+        ValueError: If `start_dim` is greater than `end_dim` after canonicalized.
+        ValueError: If `start_dim` or `end_dim` is not in range of [-input.dim, input.dim-1].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1151,8 +1627,50 @@ def flatten(input_x):
         >>> print(output.shape)
         (1, 24)
     """
-    _flatten = _get_cache_prim(P.Flatten)()
-    return _flatten(input_x)
+    def canonicalize_axis(axis, x_rank):
+        ndim = x_rank if x_rank != 0 else 1
+        if axis < -ndim or axis >= ndim:
+            const_utils.raise_value_error("'start_dim' or 'end_dim' out of range.")
+        return axis if axis >= 0 else axis + ndim
+
+    # Check the types of arguments.
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For 'flatten', argument 'input' must be Tensor.")
+    if not isinstance(start_dim, int) or not isinstance(end_dim, int):
+        raise TypeError(f"For 'flatten', both 'start_dim' and 'end_dim' must be int.")
+    check_flatten_order_const(order)
+    if order == 'F':
+        perm = F.make_range(0, F.rank(input))
+        new_order = F.tuple_reversed(perm)
+        input = _get_cache_prim(P.Transpose)()(input, new_order)
+
+    # Handle the default case.
+    x_shape = shape_(input)
+    x_rank = rank_(input)
+    if start_dim == 1 and end_dim == -1:
+        if x_rank in (0, 1):
+            return reshape_(input, (-1,))
+        return _get_cache_prim(P.Flatten)()(input)
+
+    # Check axis.
+    start_dim = canonicalize_axis(start_dim, x_rank)
+    end_dim = canonicalize_axis(end_dim, x_rank)
+    if start_dim > end_dim:
+        const_utils.raise_value_error("For 'flatten', 'start_dim' cannot come after 'end_dim'.")
+    # If input is a 0-dimensional Tensor, a 1-dimensional Tensor will be returned.
+    if x_rank in (0, 1):
+        return reshape_(input, (-1,))
+    # If no dimensions to flatten, return the original object.
+    if start_dim == end_dim:
+        return input
+    # Flatten elements along specified dimensions.
+    dim_length = 1
+    idx = start_dim
+    while idx <= end_dim:
+        dim_length *= x_shape[idx]
+        idx += 1
+    new_shape = x_shape[:start_dim] + (dim_length,) + x_shape[end_dim + 1:]
+    return reshape_(input, new_shape)
 
 
 @constexpr
@@ -1165,7 +1683,7 @@ def _check_select_type_match(scalar, tensor_type, scalar_name, tensor_name):
                         f"then the input[{tensor_name}] must be a Tensor of float32.")
 
 
-@constexpr
+@_primexpr
 def _check_select_shape_match(input_shape, cond_shape, tensor_name):
     if input_shape != cond_shape:
         raise ValueError(f"For functional operator[select], the cond shape must be same as {tensor_name} shape.")
@@ -1183,10 +1701,52 @@ def _check_select_type(is_cond_tensor, is_x_scalar, is_y_scalar, is_x_tensor, is
                         f"then the input[x] must be a Tensor.")
 
 
-def select(cond, x, y):
-    r"""
+@constexpr
+def _check_select_shape_same(cond_shape, x_shape, y_shape):
+    """Check if input of select has same shape."""
+    return cond_shape == x_shape and x_shape == y_shape and cond_shape == y_shape
+
+
+@constexpr
+def get_max_value(x, y, z):
+    """Get the maximum value of x, y and z."""
+    if x >= y and x >= z:
+        return x
+    if y >= x and y >= z:
+        return y
+    return z
+
+
+@constexpr
+def _calc_broadcast_shape(cond_shape, x_shape, y_shape):
+    """Calculate broadcast shape for select"""
+    converted_shape = []
+    cond_reverse = cond_shape[::-1]
+    x_reverse = x_shape[::-1]
+    y_reverse = y_shape[::-1]
+    max_len = get_max_value(len(cond_reverse), len(x_reverse), len(y_reverse))
+    i = 0
+    while i < max_len:
+        cond_element = 1 if i >= len(cond_reverse) else cond_reverse[i]
+        x_element = 1 if i >= len(x_reverse) else x_reverse[i]
+        y_element = 1 if i >= len(y_reverse) else y_reverse[i]
+        broadcast_element = get_max_value(cond_element, x_element, y_element)
+        if cond_element not in (1, broadcast_element):
+            raise ValueError(f"For select, condition input can not broadcast at index {i}")
+        if x_element not in (1, broadcast_element):
+            raise ValueError(f"For select, x input can not broadcast at index {i}")
+        if y_element not in (1, broadcast_element):
+            raise ValueError(f"For select, y input can not broadcast at index {i}")
+        converted_shape.append(broadcast_element)
+        i = i + 1
+    converted_shape.reverse()
+    return tuple(converted_shape)
+
+
+def select(cond, x, y):
+    r"""
     The conditional tensor determines whether the corresponding element in the output must be
-    selected from :math:`x` (if true) or :math:`y` (if false) based on the value of each element.
+    selected from `x` (if true) or `y` (if false) based on the value of each element.
 
     It can be defined as:
 
@@ -1200,20 +1760,20 @@ def select(cond, x, y):
         cond (Tensor[bool]): The condition tensor, decides which element is chosen.
           The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
         x (Union[Tensor, int, float]): The first Tensor or number to be selected.
-          If x is a Tensor, the shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`. If x is an int or a float,
-          it will be cast to the type of int32 or float32, and broadcast to the same shape as y.
-          One of x and y must be a Tensor.
+          If x is a Tensor, the shape is or can be broadcadt to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
+          If x is an int or a float, it will be cast to the type of int32 or float32,
+          and broadcast to the same shape as y. One of x and y must be a Tensor.
         y (Union[Tensor, int, float]): The second Tensor or number to be selected.
-          If y is a Tensor, The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`. If y is an int or a float,
-          it will be cast to the type of int32 or float32, and broadcast to the same shape as x.
-          One of x and y must be a Tensor.
+          If y is a Tensor, The shape is or can be broadcadt to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
+          If y is an int or a float, it will be cast to the type of int32 or float32,
+          and broadcast to the same shape as x. One of x and y must be a Tensor.
 
     Returns:
         Tensor, has the same shape as `cond`.
 
     Raises:
         TypeError: If `x` or `y` is not a Tensor, int or float.
-        ValueError: The shapes of inputs are different.
+        ValueError: The shapes of inputs can not be broadcast.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1260,6 +1820,19 @@ def select(cond, x, y):
             input_y = cast_(input_y, mstype.int32)
         else:
             input_y = cast_(input_y, mstype.float32)
+
+    if is_x_tensor and is_y_tensor and is_cond_tensor:
+        x_shape = F.shape(x)
+        y_shape = F.shape(y)
+        cond_shape = F.shape(cond)
+        all_constant = F.isconstant(cond_shape) and F.isconstant(x_shape) and F.isconstant(y_shape)
+        if all_constant and not _check_select_shape_same(cond_shape, x_shape, y_shape):
+            broadcast_shape = _calc_broadcast_shape(cond_shape, x_shape, y_shape)
+            new_cond = F.broadcast_to(cond, broadcast_shape)
+            new_x = F.broadcast_to(x, broadcast_shape)
+            new_y = F.broadcast_to(y, broadcast_shape)
+            return tensor_select_(new_cond, new_x, new_y)
+
     return tensor_select_(cond, input_x, input_y)
 
 
@@ -1279,9 +1852,9 @@ def strided_slice(input_x,
     Starting from the beginning position, the fragment continues adding strides to the index until
     all dimensions are not less than the ending position.
 
-    Note:
-        - `begin` 、 `end` and `strides` must have the same shape.
-        - `begin` 、 `end` and `strides` are all 1-D Tensor,  and their shape size
+    .. warning::
+        - `begin` , `end` and `strides` must have the same shape.
+        - `begin` , `end` and `strides` are all 1-D Tensor,  and their shape size
           must not greater than the dim of `input_x`.
 
     During the slicing process, the fragment (end-begin)/strides are extracted from each dimension.
@@ -1321,7 +1894,7 @@ def strided_slice(input_x,
 
       If the ith bit of `ellipsis_mask` is 1, as many unspecified dimensions as needed
       will be inserted between other dimensions. Only one non-zero bit is allowed
-      in `ellipsis_mask`. For a 5*6*7*8 Tensor `input_x`,  `input_x[2:,...,:6]`
+      in `ellipsis_mask`. For Tensor `input_x` with shape :math:`(5, 6, 7, 8)`,  `input_x[2:,...,:6]`
       is equivalent to `input_x[2:5,:,:,0:6]` ,  `input_x[2:,...]` is equivalent
       to `input_x[2:5,:,:,:]`.
 
@@ -1449,7 +2022,6 @@ def slice(input_x, begin, size):
 
     Args:
         input_x (Tensor): The target tensor.
-            The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
         begin (Union[tuple, list]): The beginning of the slice. Only constant value(>=0) is allowed.
         size (Union[tuple, list]): The size of the slice. Only constant value is allowed.
 
@@ -1488,81 +2060,34 @@ def slice(input_x, begin, size):
     return tensor_slice(input_x, begin, size)
 
 
-def concat(input_x, axis=0):
-    r"""
-    Connect input tensors along with the given axis.
-
-    The input data is a tuple of tensors. These tensors have the same rank :math:`R`. Set the given axis as :math:`m`,
-    and :math:`0 \le m < R`. Set the number of input tensors as :math:`N`. For the :math:`i`-th tensor :math:`t_i`,
-    it has the shape of :math:`(x_1, x_2, ..., x_{mi}, ..., x_R)`. :math:`x_{mi}` is the :math:`m`-th dimension of the
-    :math:`t_i`. Then, the shape of the output tensor is
-
-    .. math::
-
-        (x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)
-
-    Args:
-        input_x (tuple, list): A tuple or a list of input tensors.
-            Suppose there are two tensors in this tuple or list, namely t1 and t2.
-            To perform `concat` in the axis 0 direction, except for the :math:`0`-th axis,
-            all other dimensions should be equal, that is,
-            :math:`t1.shape[1] = t2.shape[1], t1.shape[2] = t2.shape[2], ..., t1.shape[R-1] = t2.shape[R-1]`,
-        axis (int): The specified axis, whose value is in range :math:`[-R, R)`. Default: 0.
-
-    Returns:
-        Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
-            The data type is the same with `input_x`.
-
-    Raises:
-        TypeError: If `axis` is not an int.
-        ValueError: If `input_x` have different dimension of tensor.
-        ValueError: If `axis` not in range :math:`[-R, R)`.
-        RuntimeError: If tensor's shape in `input_x` except for `axis` are different.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
-        >>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
-        >>> output = ops.concat((input_x1, input_x2))
-        >>> print(output)
-        [[0. 1.]
-         [2. 1.]
-         [0. 1.]
-         [2. 1.]]
-        >>> output = ops.concat((input_x1, input_x2), 1)
-        >>> print(output)
-        [[0. 1. 0. 1.]
-         [2. 1. 2. 1.]]
-    """
-    _concat = _get_cache_prim(P.Concat)(axis)
-    return _concat(input_x)
+def concat(tensors, axis=0):
+    """Alias for :func:`mindspore.ops.cat()`"""
+    return cat(tensors, axis)
 
 
-def stack(input_x, axis=0):
+def stack(tensors, axis=0):
     r"""
     Stacks a list of tensors in specified axis.
 
     Stacks the list of input tensors with the same rank `R`, output is a tensor of rank `(R+1)`.
 
     Given input tensors of shape :math:`(x_1, x_2, ..., x_R)`. Set the number of input tensors as `N`.
-    If :math:`0 \le axis`, the shape of the output tensor is
+    If :math:`axis \ge 0`, the shape of the output tensor is
     :math:`(x_1, x_2, ..., x_{axis}, N, x_{axis+1}, ..., x_R)`.
 
     Args:
-        input_x (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape and type.
+        tensors (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape and type.
         axis (int): Dimension to stack. Default: 0.
             Negative values wrap around. The range is [-(R+1), R+1).
 
     Returns:
-        Tensor. A stacked Tensor with the same type as `input_x`.
+        Tensor. A stacked Tensor with the same type as `tensors`.
 
     Raises:
-        TypeError: If the data types of elements in `input_x` are not the same.
-        ValueError: If the length of `input_x` is not greater than 1;
+        TypeError: If the data types of elements in `tensors` are not the same.
+        ValueError: If the length of `tensors` is not greater than 0;
                     or if axis is out of the range [-(R+1), R+1);
-                    or if the shapes of elements in input_x are not the same.
+                    or if the shapes of elements in tensors are not the same.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1576,7 +2101,7 @@ def stack(input_x, axis=0):
          [2. 3.]]
     """
     _stack = _get_cache_prim(P.Stack)(axis)
-    return _stack(input_x)
+    return _stack(tensors)
 
 
 def unstack(input_x, axis=0):
@@ -1615,17 +2140,17 @@ def unstack(input_x, axis=0):
     return _unstack(input_x)
 
 
-def unbind(x, dim=0):
+def unbind(input, dim=0):
     r"""
     Removes a tensor dimension in specified axis.
 
     Unstacks a tensor of rank `R` along axis dimension, and output tensors will have rank `(R-1)`.
 
-    Given a tensor of shape :math:`(x_1, x_2, ..., x_R)`. If :math:`0 \le axis`,
-    the shape of tensor in output is :math:`(x_1, x_2, ..., x_{axis}, x_{axis+2}, ..., x_R)`.
+    Given a tensor of shape :math:`(n_1, n_2, ..., n_R)` and a specified `dim`,
+    shape of the output tensors is :math:`(n_1, n_2, ..., n_{dim}, n_{dim+2}, ..., n_R)`.
 
     Args:
-        x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`.
+        input (Tensor): The shape is :math:`(n_1, n_2, ..., n_R)`.
             A tensor to be unstacked and the rank of the tensor must be greater than 0.
         dim (int): Dimension along which to unpack. Negative values wrap around. The range is [-R, R). Default: 0.
 
@@ -1646,7 +2171,7 @@ def unbind(x, dim=0):
         Tensor(shape=[3], dtype=Int64, value=[7, 8, 9]))
     """
     _unstack = _get_cache_prim(P.Unstack)(dim)
-    return _unstack(x)
+    return _unstack(input)
 
 
 def expand_dims(input_x, axis):
@@ -1684,27 +2209,23 @@ def expand_dims(input_x, axis):
     return expand_dims_(input_x, axis)
 
 
-def unsqueeze(input_x, dim):
+def unsqueeze(input, dim):
     """
-    Adds an additional dimension to `input_x` at the given dim.
-
-    Note:
-        If the specified dim is a negative number, the index is counted
-        backward from the end and starts at 1.
+    Adds an additional dimension to `input` at the given dim.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        input (Tensor): The shape of tensor is :math:`(n_1, n_2, ..., n_R)`.
         dim (int): Specifies the dimension index at which to expand
-            the shape of `input_x`. The value of `dim` must be in the range
-            `[-input_x.ndim-1, input_x.ndim]`. Only constant value is allowed.
+            the shape of `input`. The value of `dim` must be in the range
+            `[-input.ndim-1, input.ndim]`. Only constant value is allowed.
 
     Returns:
-        Tensor, the shape of tensor is :math:`(1, x_1, x_2, ..., x_R)` if the
-        value of `dim` is 0. It has the same data type as `input_x`.
+        Tensor, the shape of tensor is :math:`(1, n_1, n_2, ..., n_R)` if the
+        value of `dim` is 0. It has the same data type as `input`.
 
     Raises:
         TypeError: If `dim` is not an int.
-        ValueError: If `dim` is not in the valid range :math:`[-input_x.ndim-1, input_x.ndim]`.
+        ValueError: If `dim` is not in the valid range :math:`[-input.ndim-1, input.ndim]`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1716,16 +2237,16 @@ def unsqueeze(input_x, dim):
         [[[2. 2.]
           [2. 2.]]]
     """
-    return expand_dims_(input_x, dim)
+    return expand_dims_(input, dim)
 
 
-def squeeze(input_x, axis=()):
+def squeeze(input, axis=None):
     """
     Return the Tensor after deleting the dimension of size 1 in the specified `axis`.
 
-    If :math:`axis=()`, it will remove all the dimensions of size 1.
+    If :math:`axis=None`, it will remove all the dimensions of size 1.
     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=()`, input shape is (A, 1, B, C, 1, D),
+    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 not be
     changed when :math:`axis=0` , but when :math:`axis=1` , the shape of the input Tensor will be changed to (A, B).
@@ -1736,16 +2257,16 @@ def squeeze(input_x, axis=()):
         - The dimension index starts at 0 and must be in the range `[-input.ndim, input.ndim]`.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
         axis (Union[int, tuple(int)]): Specifies the dimension indexes of shape to be removed, which will remove
             all the dimensions of size 1 in the given axis parameter. If specified, it must be int32 or int64.
-            Default: (), an empty tuple.
+            Default: None, an empty tuple will be used.
 
     Returns:
         Tensor, the shape of tensor is :math:`(x_1, x_2, ..., x_S)`.
 
     Raises:
-        TypeError: If `input_x` is not a tensor.
+        TypeError: If `input` is not a tensor.
         TypeError: If `axis` is neither an int nor tuple.
         TypeError: If `axis` is a tuple whose elements are not all int.
         ValueError: If the corresponding dimension of the specified axis isn't equal to 1.
@@ -1754,18 +2275,20 @@ def squeeze(input_x, axis=()):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-        >>> output = ops.squeeze(input_x)
+        >>> input = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
+        >>> output = ops.squeeze(input)
         >>> print(output)
         [[1. 1.]
          [1. 1.]
          [1. 1.]]
     """
+    if axis is None:
+        axis = ()
     squeeze_ = _get_cache_prim(P.Squeeze)(axis)
-    return squeeze_(input_x)
+    return squeeze_(input)
 
 
-def transpose(input_x, input_perm):
+def transpose(input, input_perm):
     """
     Permutes the dimensions of the input tensor according to input permutation.
 
@@ -1773,35 +2296,35 @@ def transpose(input_x, input_perm):
     To convert a 1-D array into a 2D column vector please refer the class: mindspore.ops.ExpandDims.
     For a 2-D array, this is a standard matrix transpose. For an n-D array, if axes are given,
     their order indicates how the axes are permuted (see Examples).
-    If axes are not provided and a.shape = (i[0], i[1], ... i[n-2], i[n-1]),
-    then a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0]).
+    If axes are not provided and a.shape is :math:`(i[0], i[1], ... i[n-2], i[n-1])`,
+    then a.transpose().shape is :math:`(i[n-1], i[n-2], ... i[1], i[0])`.
 
     Note:
-        On GPU and CPU, if the value of `input_perm` is negative, its actual value is `input_perm[i] + rank(input_x)`.
+        On GPU and CPU, if the value of `input_perm` is negative, its actual value is `input_perm[i] + rank(input)`.
         Negative value of `input_perm` is not supported on Ascend.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
         input_perm (tuple[int]): The permutation to be converted. The elements in `input_perm` are composed of
-            the indexes of each dimension of `input_x`. The length of `input_perm` and the shape of `input_x` must be
-            the same. Only constant value is allowed. Must be in the range [-rank(input_x), rank(input_x)).
+            the indexes of each dimension of `input`. The length of `input_perm` and the shape of `input` must be
+            the same. Only constant value is allowed. Must be in the range [-rank(input), rank(input)).
 
     Returns:
-        Tensor, the type of output tensor is the same as `input_x` and the shape of output tensor is decided by the
-        shape of `input_x` and the value of `input_perm`.
+        Tensor, the type of output tensor is the same as `input` and the shape of output tensor is decided by the
+        shape of `input` and the value of `input_perm`.
 
     Raises:
         TypeError: If `input_perm` is not a tuple.
-        ValueError: If length of shape of `input_x` is not equal to length of shape of `input_perm`.
+        ValueError: If length of shape of `input` is not equal to length of shape of `input_perm`.
         ValueError: If the same element exists in `input_perm`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
+        >>> input = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
         >>> input_perm = (0, 2, 1)
-        >>> output = ops.transpose(input_x, input_perm)
+        >>> output = ops.transpose(input, input_perm)
         >>> print(output)
         [[[ 1.  4.]
           [ 2.  5.]
@@ -1810,7 +2333,7 @@ def transpose(input_x, input_perm):
           [ 8. 11.]
           [ 9. 12.]]]
     """
-    return transpose_(input_x, input_perm)
+    return transpose_(input, input_perm)
 
 
 def scatter_mul(input_x, indices, updates):
@@ -1914,9 +2437,20 @@ def scatter_max(input_x, indices, updates):
     Using given values to update tensor value through the max operation, along with the input indices.
     This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value.
 
+    for each :math:`i, ..., j` in `indices.shape`:
+
+    .. math::
+
+        \text{input_x}[\text{indices}[i, ..., j], :]
+        = max(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
+
+    Inputs of `input_x` and `updates` follow the implicit type conversion rules to keep the data types consistent.
+    If they have different data types, the lower priority data type will be converted to the relatively highest
+    priority data type. A RuntimeError will be reported 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.
-            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`,
             the data type is same as `input_x`, the shape is `indices.shape + x.shape[1:]`.
@@ -1933,7 +2467,7 @@ def scatter_max(input_x, indices, updates):
                       and `updates` is greater than 8 dimensions.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Parameter(Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32), name="input_x")
@@ -1954,7 +2488,7 @@ def scatter_add(input_x, indices, updates):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
+            The shape is :math:`(N, *)` where :math:`*` means,any number of additional dimensions.
         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:]`.
@@ -2007,7 +2541,6 @@ def scatter_min(input_x, indices, updates):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         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:]`.
@@ -2060,20 +2593,19 @@ def scatter_div(input_x, indices, updates):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-          The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         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`, the shape is `indices.shape + input_x.shape[1:]`.
+        updates (Tensor): The tensor doing the divide operation with `input_x`, the data type is same as `input_x`,
+          the shape is `indices.shape + input_x.shape[1:]`.
 
     Returns:
-        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
+        Tensor, the updated `input_x`, has the same type and shape as `input_x`.
 
     Raises:
-        TypeError: If `indices` is not an int32 or an int64.
+        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 is required
+                      when data type conversion of Parameter is not supported.
         RuntimeError: On the Ascend platform, the input data dimension of `input_x` , `indices`
                       and `updates` is greater than 8 dimensions.
 
@@ -2246,7 +2778,6 @@ def scatter_update(input_x, indices, updates):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         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,
@@ -2297,7 +2828,6 @@ def scatter_nd_add(input_x, indices, updates, use_locking=False):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         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`,
@@ -2370,7 +2900,6 @@ def scatter_nd_sub(input_x, indices, updates, use_locking=False):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         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.
@@ -2442,8 +2971,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): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+        input_x (Parameter): Input parameter.
         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`.
@@ -2516,7 +3044,6 @@ def scatter_nd_div(input_x, indices, updates, use_locking=False):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
         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`.
@@ -2590,7 +3117,6 @@ def scatter_nd_max(input_x, indices, updates, use_locking=False):
 
     Args:
         input_x (Parameter): The target tensor, with data type of Parameter.
-            The shape is :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
         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`.
@@ -2725,31 +3251,32 @@ def sort(input_x, axis=-1, descending=False):
     Args:
         input_x(Tensor): The input tensor to sort.
             The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        axis (int): The dimension to sort along. Default: -1.
-        descending (bool): Controls the sort order. If descending is True then the elements
-            are sorted in descending order by value. Default: False.
+        axis (int, optional): The dimension to sort along. Default: -1.
+        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.
 
     .. warning::
-        Currently, the data types of Float16, UInt8, Int8, Int16, Int32, Int64 are supported.
+        Currently, the data types of Float16, UInt8, Int8, Int16, Int32, Int64 are well supported.
         If use Float32, it may cause loss of accuracy.
 
     Returns:
-        y1(Tensor) - A tensor whose values are the sorted values, with the same shape and data type as input.
-        y2(Tensor) - The indices of the elements in the original input tensor. Data type is int32.
+
+        - 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 int32.
 
     Raises:
         TypeError: If `axis` is not an int.
         TypeError: If `descending` is not a bool.
-        TypeError: If dtype of `x` is neither float16, float32, uint8, int8, int16, int32, int64.
-        ValueError: If `axis` is not in range of [-len(x.shape), len(x.shape)).
+        TypeError: If dtype of `input_x` is neither float16, float32, uint8, int8, int16, int32, int64.
+        ValueError: If `axis` is not in range of [-len(input_x.shape), len(input_x.shape)).
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-        >>> sort = ops.Sort()
-        >>> output = sort(x)
+        >>> output = ops.sort(x)
         >>> # The output below is based on the Ascend platform.
         >>> print(output)
         (Tensor(shape=[3, 3], dtype=Float16, value=
@@ -2764,7 +3291,36 @@ def sort(input_x, axis=-1, descending=False):
     return _sort(input_x)
 
 
-def gather(input_params, input_indices, axis):
+def argsort(input, axis=-1, descending=False):
+    r"""
+    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
+
+    Args:
+        input(Tensor): The input tensor to sort.
+        axis (int): The axis to sort along. Default: -1, means the last axis
+        descending (bool): The sort order. If `descending` is True then the elements
+            are sorted in descending order by value. Otherwise sort in ascending order. Default: False.
+
+    Returns:
+        Tensor, the indices of sorted input tensor. Data type is int32.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> sort = ops.argsort(x)
+        >>> print(sort)
+        [[2 1 0]
+         [2 0 1]
+         [0 1 2]]
+    """
+    _sort = _get_cache_prim(P.Sort)(axis, descending)
+    _, arg_sort = _sort(input)
+    return arg_sort
+
+
+def gather(input_params, input_indices, axis, batch_dims=0):
     r"""
     Returns the slice of the input tensor corresponding to the elements of `input_indices` on the specified `axis`.
 
@@ -2775,22 +3331,24 @@ def gather(input_params, input_indices, axis):
     where params represents the input `input_params`, and indices represents the index to be sliced `input_indices`.
 
     .. note::
-         1. The value of input_indices must be in the range of `[0, input_param.shape[axis])`, the result is undefined
-            out of range.
+        1. The value of input_indices must be in the range of `[0, input_param.shape[axis])`, the result is undefined
+           out of range.
 
-         2. The data type of input_params cannot be
-            `bool_ <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/mindspore.html#mindspore.dtype>`_ on Ascend
-            platform currently.
+        2. The data type of input_params cannot be
+           `bool_ <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ on Ascend
+           platform currently.
 
     Args:
         input_params (Tensor): The original Tensor. The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
         input_indices (Tensor): Index tensor to be sliced, the shape of tensor is :math:`(y_1, y_2, ..., y_S)`.
             Specifies the indices of elements of the original Tensor. The data type can be int32 or int64.
-        axis (int): Specifies the dimension index to gather indices.
+        axis (int): Specifies the dimension index to gather indices. It must be greater than or equal to `batch_dims`.
+        batch_dims (int): Specifies the number of batch dimensions. It must be less than or euqal to the rank
+                          of `input_indices`. Default: 0.
 
     Returns:
         Tensor, the shape of tensor is
-        :math:`input\_params.shape[:axis] + input\_indices.shape + input\_params.shape[axis + 1:]`.
+        :math:`input\_params.shape[:axis] + input\_indices.shape[batch\_dims:] + input\_params.shape[axis + 1:]`.
 
     Raises:
         TypeError: If `axis` is not an int.
@@ -2814,8 +3372,8 @@ def gather(input_params, input_indices, axis):
         >>> axis = 0
         >>> output = ops.gather(input_params, input_indices, axis)
         >>> print(output)
-        [[ 1. 3.]
-         [ 3. 7.]]
+        [[1. 3.]
+         [3. 7.]]
         >>> # case3: input_indices is a Tensor with shape (2, ) and
         >>> # input_params is a Tensor with shape (3, 4) and axis is 0.
         >>> input_params = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]), mindspore.float32)
@@ -2823,20 +3381,20 @@ def gather(input_params, input_indices, axis):
         >>> axis = 0
         >>> output = ops.gather(input_params, input_indices, axis)
         >>> print(output)
-        [[1.  2.  3.  4.]
-         [9. 10. 11. 12.]]
+        [[ 1.  2.  3.  4.]
+         [ 9. 10. 11. 12.]]
         >>> # case4: input_indices is a Tensor with shape (2, ) and
-        >>> # input_params is a Tensor with shape (3, 4) and axis is 1.
+        >>> # input_params is a Tensor with shape (3, 4) and axis is 1, batch_dims is 1.
         >>> input_params = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]), mindspore.float32)
-        >>> input_indices = Tensor(np.array([0, 2]), mindspore.int32)
+        >>> input_indices = Tensor(np.array([0, 2, 1]), mindspore.int32)
         >>> axis = 1
-        >>> output = ops.gather(input_params, input_indices, axis)
+        >>> batch_dims = 1
+        >>> output = ops.gather(input_params, input_indices, axis, batch_dims)
         >>> print(output)
-        [[1.  3.]
-         [5.  7.]
-         [9. 11.]]
+        [ 1.  7. 10.]
     """
-    return gather_(input_params, input_indices, axis)
+    _gather = _get_cache_prim(P.Gather)(batch_dims)
+    return _gather(input_params, input_indices, axis)
 
 
 def gather_d(x, dim, index):
@@ -2860,7 +3418,7 @@ def gather_d(x, dim, index):
     return gather_d_(x, dim, index)
 
 
-def gather_elements(x, dim, index):
+def gather_elements(input, dim, index):
     """
     Gathers elements along an axis specified by dim.
 
@@ -2874,25 +3432,26 @@ def gather_elements(x, dim, index):
 
         output[i][j][k] = x[i][j][index[i][j][k]]  # if dim == 2
 
-    `x` and `index` have the same length of dimensions, and all dimensions except `dim` have the same size.
-    If `dim` = i, `x` is an n-D tensor with shape :math:`(z_0, z_1, ..., z_i, ..., z_{n-1})`,
+    `input` and `index` have the same length of dimensions, and all dimensions except `dim` have the same size.
+    If `dim` = i, `input` is an n-D tensor with shape :math:`(z_0, z_1, ..., z_i, ..., z_{n-1})`,
     the `index` must be an n-D tensor with shape :math:`(z_0, z_1, ..., y, ..., z_{n-1})`
     where `y`>=1 and the output will have the same shape with `index`.
 
     Args:
-        x (Tensor): The input tensor.
-        dim (int): The axis along which to index. It must be int32 or int64. The value range is [-x.ndim, x.ndim).
+        input (Tensor): The input tensor.
+        dim (int): The axis along which to index. It must be int32 or int64. The value range is [-input.ndim,
+            input.ndim).
         index (Tensor): The indices of elements to gather. It can be one of the following data types:
-            int32, int64. The value range of each index element is [-x.shape(dim), x.shape(dim)).
+            int32, int64. The value range of each index element is [-input.shape(dim), input.shape(dim)).
 
     Returns:
-        Tensor, has the same shape as index tensor, the shape of tensor is :math:`(z_1, z_2, ..., z_{n-1})`,
-        and has the same data type with `x`.
+        Tensor, has the same shape as index tensor, the shape of tensor is :math:`(z_0, z_1, ..., y, ..., z_{n-1})`,
+        and has the same data type with `input`.
 
     Raises:
         TypeError: If dtype of `dim` or `index` is neither int32 nor int64.
-        ValueError: If length of shape of `x` is not equal to length of shape of `index`.
-        ValueError: If the size of the dimension except `dim` is not equal between `x` and `index`.
+        ValueError: If length of shape of `input` is not equal to length of shape of `index`.
+        ValueError: If the size of the dimension except `dim` is not equal between `input` and `index`.
         ValueError: If the value of `dim` is not in the expected range.
 
     Supported Platforms:
@@ -2910,7 +3469,7 @@ def gather_elements(x, dim, index):
         [[1 1]
          [4 3]]
     """
-    return gather_d_(x, dim, index)
+    return gather_d_(input, dim, index)
 
 
 def gather_nd(input_x, indices):
@@ -2930,7 +3489,6 @@ def gather_nd(input_x, indices):
 
     Args:
         input_x (Tensor): The target tensor to gather values.
-            The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
         indices (Tensor): The index tensor, with int32 or int64 data type.
 
     Returns:
@@ -2984,6 +3542,7 @@ def tensor_scatter_add(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3036,6 +3595,7 @@ def tensor_scatter_sub(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3083,6 +3643,7 @@ def tensor_scatter_max(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -3134,6 +3695,7 @@ def tensor_scatter_min(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3186,8 +3748,7 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         the corresponding `updates` will not be updated to `input_x`.
 
     Args:
-        input_x (Tensor): The target tensor.
-          The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
+        input_x (Tensor): The target tensor. The rank of `input` must be at least 1.
         indices (Tensor): The index to do add operation whose data type must be mindspore.int32 or
           mindspore.int64. Same rank as input_x. And accepted range is [-s, s) where s is the size along axis.
         updates (Tensor): The tensor doing the add operation with `input_x`, has the same type as input_x,
@@ -3204,7 +3765,7 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         ValueError: If the shape of `updates` is not equal to the shape of `indices`.
         ValueError: If the rank of `updates` is not equal to the rank of `input_x`.
         RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                        is required when data type conversion of Parameter is not supported.
+            is required when data type conversion of Parameter is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3223,6 +3784,64 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
     return _tensor_scatter_elements(input_x, indices, updates)
 
 
+def scatter(input, axis, index, src):
+    """
+    Update the value in `src` to `input` according to the specified index.
+    Refer to :func:`mindspore.ops.tensor_scatter_elements` for more details.
+
+    Args:
+        input (Tensor): The target tensor. The rank of `input` must be at least 1.
+        axis (int): Which axis to scatter. Accepted range is [-r, r) where r = rank(input).
+        index (Tensor): The index to do update operation whose data type must be mindspore.int32 or
+            mindspore.int64. Same rank as `input` . And accepted range is [-s, s) where s is the size along axis.
+        src (Tensor): The tensor doing the update operation with `input` , has the same type as `input` ,
+            and the shape of `src` should be equal to the shape of `index` .
+
+    Returns:
+        Tensor, has the same shape and type as `input` .
+
+    Raises:
+        TypeError: If `index` is neither int32 nor int64.
+        ValueError: If anyone of the rank among `input` , `index` and `src` less than 1.
+        ValueError: If the 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`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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.scatter(input=input, axis=1, index=index, src=src)
+        >>> print(out)
+        [[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.scatter(input=input, axis=0, index=index, src=src)
+        >>> print(out)
+        [[1. 2. 3. 0. 0.]
+        [0. 0. 0. 0. 0.]
+        [4. 5. 6. 0. 0.]
+        [0. 0. 0. 0. 0.]
+        [7. 8. 9. 0. 0.]]
+        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[0, 2, 4], [0, 2, 4], [0, 2, 4]]), dtype=ms.int64)
+        >>> out = ops.scatter(input=input, axis=1, index=index, src=src)
+        >>> print(out)
+        [[1. 0. 2. 0. 3.]
+        [4. 0. 5. 0. 6.]
+        [7. 0. 8. 0. 9.]
+        [0. 0. 0. 0. 0.]
+        [0. 0. 0. 0. 0.]]
+    """
+    return F.tensor_scatter_elements(input_x=input, indices=index, updates=src, axis=axis)
+
+
 def space_to_batch_nd(input_x, block_size, paddings):
     r"""
     Divides a tensor's spatial dimensions into blocks and combines the block sizes with the original batch.
@@ -3231,8 +3850,7 @@ def space_to_batch_nd(input_x, block_size, paddings):
     and after division, the output tensor's spatial dimension is the corresponding number of blocks.
     The output tensor's batch dimension is the product of the original batch and the product of `block_size`.
     Before division, the spatial dimensions of the input are zero padded according to paddings if necessary.
-    Assume input shape is :math:`(n, c_1, ... c_k, w_1, ..., w_M)` with
-    :math:`block\_size` and :math:`paddings`, then the shape of the output tensor will be
+    Assume input shape is :math:`(n, c_1, ... c_k, w_1, ..., w_M)`, then the shape of the output tensor will be
     :math:`(n', c_1, ... c_k, w'_1, ..., w'_M)`, where
 
     .. math::
@@ -3294,11 +3912,13 @@ def batch_to_space_nd(input_x, block_shape, crops):
     respectively.
 
     If the input shape is :math:`(n, c_1, ... c_k, w_1, ..., w_M)`, the output shape is
-    :math:`(n, c_1, ... c_k, w_1, ..., w_M)`.
-
-    :math:`n' = n//(block\_shape[0]*...*block\_shape[M-1])`
+    :math:`(n', c_1, ... c_k, w'_1, ..., w'_M)`, where
 
-    :math:`w'_i = w_i*block\_shape[i-1]-crops[i-1][0]-crops[i-1][1]`
+    .. math::
+            \begin{array}{ll} \\
+                n' = n//(block\_shape[0]*...*block\_shape[M-1]) \\
+                w'_i = w_i*block\_shape[i-1]-crops[i-1][0]-crops[i-1][1]
+            \end{array}
 
     Args:
         input_x (Tensor): The input tensor. It must be greater or equal to 2-D tensor(equal to 4-D tensor on Ascend),
@@ -3311,17 +3931,10 @@ def batch_to_space_nd(input_x, block_shape, crops):
             Each contains 2 integer values. All values must be >= 0. crops[i] specifies the crops values for spatial
             dimension i, which corresponds to input dimension i + offset,where offset = N-M, and N is the number of
             input dimensions. It is required that
-
             :math:`input\_shape[i+offset]*block\_shape[i] > crops[i][0]+crops[i][1]`
 
     Returns:
-        Tensor, the output tensor with the same type as input. Assume input shape is
-        :math:`(n, c_1, ... c_k, w_1, ..., w_M)` with block_shape and crops. The output shape will be
-        :math:`(n', c_1, ... c_k, w'_1, ..., w'_M)`, where
-
-        :math:`n' = n//(block\_shape[0]*...*block\_shape[M-1])`
-
-        :math:`w'_i = w_i*block\_shape[i-1]-crops[i-1][0]-crops[i-1][1]`
+        Tensor, the output tensor with the same type as input.
 
     Raises:
         TypeError: If `block_shape` is not one of list, tuple, int.
@@ -3351,19 +3964,19 @@ def batch_to_space_nd(input_x, block_shape, crops):
     return _batch_to_space_nd(input_x)
 
 
-def nonzero(x):
+def nonzero(input):
     """
     Return a Tensor of the positions of all non-zero values.
 
     Args:
-        x (Tensor): The shape of Tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is Number or Bool.
+        input (Tensor): The shape of Tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is int, float or bool.
 
     Returns:
         Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
 
     Raises:
-        TypeError: If `x` is not Tensor.
-        ValueError: If 'x' dim equal to 0.
+        TypeError: If `input` is not Tensor.
+        ValueError: If dim of `x` equals to 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3378,8 +3991,14 @@ def nonzero(x):
         >>> print(output)
         [[0 0 0]
          [0 1 0]]
+        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+        >>> output = ops.nonzero(x)
+        >>> print(output)
+        [[0]
+         [2]
+         [4]]
     """
-    return nonzero_(x)
+    return nonzero_(input)
 
 
 def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_LEFT"):
@@ -3394,34 +4013,44 @@ def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_
 
     Args:
         x (Tensor): The diagonal Tensor.
-        k (Union[int, Tensor], optional): A Tensor of type int32. Diagonal offsets. Positive value means superdiagonal,
+        k (Union[int, Tensor], optional): Diagonal offsets. A Tensor of type int32. Positive value means superdiagonal,
             0 refers to the main diagonal, and negative value means subdiagonals. `k` can be a single integer
             (for a single diagonal) or a pair of integers specifying the low and high ends of a matrix band.
             k[0] must not be larger than k[1]. The value must be in the range of given or derivated `num_rows`
             and `num_cols`, meaning value of k must be in (-num_rows, num_cols). Default: 0.
-        num_rows (Union[int, Tensor], optional): A Tensor of type int32 with only one value. The number of rows of the
-            output Tensor. If `num_rows` is -1, indicating that the innermost matrix of the output Tensor is a square
+        num_rows (Union[int, Tensor], optional): The number of rows of the output Tensor. A Tensor of type int32 with
+            only one value. If `num_rows` is -1, indicating that the innermost matrix of the output Tensor is a square
             matrix, and the real number of rows will be derivated by other inputs. That is
             :math:`num\_rows = x.shape[-1] - min(k[1], 0)`. Otherwise, the value must be equal or greater than
             :math:`x.shape[-1] - min(k[1], 0)`. Default: -1.
-        num_cols (Union[int, Tensor], optional): A Tensor of type int32 with only one value.
-            The number of columns of
-            the output Tensor. If `num_cols` is -1, indicating that the innermost matrix of the output
+        num_cols (Union[int, Tensor], optional): The number of columns of
+            the output Tensor. A Tensor of type int32 with only one value.
+            If `num_cols` is -1, indicating that the innermost matrix of the output
             Tensor is a square matrix, and the real number of columns will be derivated by other inputs.
             That is :math:`num\_cols = x.shape[-1] + max(k[0], 0)`. Otherwise, the value must be equal or
             greater than :math:`x.shape[-1] - min(k[1], 0)`.  Default: -1.
-        padding_value (Union[int, float, Tensor], optional): A Tensor with only one value. Have the same dtype as x.
-            The number to fill the area outside the specified diagonal band.  Default: 0.
-        align (str, optional): An optional string from: "RIGHT_LEFT"(default), "LEFT_RIGHT", "LEFT_LEFT",
-            "RIGHT_RIGHT". Align is a string specifying how superdiagonals and subdiagonals should be aligned,
-            respectively. "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals
-            to the left (right-pads the row).
+        padding_value (Union[int, float, Tensor], optional): The number to fill the area outside the specified
+            diagonal band. A Tensor with only one value. Have the same dtype as x. Default: 0.
+        align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
+            Supported values:"RIGHT_LEFT", "LEFT_RIGHT", "LEFT_LEFT", "RIGHT_RIGHT".
+            Default: "RIGHT_LEFT".
+
+            - When set to "RIGHT_LEFT", the alignment of superdiagonals will be towards the right side
+              (padding the row on the left), while subdiagonals will be towards the left side
+              (padding the row on the right)
+            - When set to "LEFT_RIGHT", the alignment of superdiagonals will be towards the left side
+              (padding the row on the right), while subdiagonals will be towards the right side
+              (padding the row on the left)
+            - When set to "LEFT_LEFT", the alignment of  both superdiagonals and subdiagonals will be towards
+              the left side(padding the row on the right).
+            - When set to "RIGHT_RIGHT", the alignment of both superdiagonals and subdiagonals will be towards
+              the right side(padding the row on the left).
 
     Returns:
         A Tensor. Has the same type as `x`.
-        Suppose `x` has r dimensions with shape `(I, J, ..., M, N)`. The output Tensor has rank r + 1 with shape
-        `(I, J, ..., M, num_rows, num_cols)` when only one diagonal is given (k is an integer or k[0] == k[1]).
-        Otherwise, it has rank r with shape `(I, J, ..., num_rows, num_cols)`.
+        Suppose `x` has r dimensions with shape :math:`(I, J, ..., M, N)` . The output Tensor has rank r + 1 with shape
+        :math:`(I, J, ..., M, num_rows, num_cols)` when only one diagonal is given (k is an integer or k[0] == k[1]).
+        Otherwise, it has rank r with shape :math:`(I, J, ..., num_rows, num_cols)` .
 
     Raises:
         TypeError: If `x` is not Tensor.
@@ -3495,11 +4124,11 @@ def matrix_diag_part(x, k=0, padding_value=0, align="RIGHT_LEFT"):
 
     Returns:
         A Tensor. Has the same type as `x`.
-        Assume `x` has r dimensions :math:`[I, J, ..., L, M, N]`. Let `max_diag_len` be the maximum length among all
+        Assume `x` has r dimensions :math:`(I, J, ..., L, M, N)` . Let `max_diag_len` be the maximum length among all
         diagonals to be extracted, :math:`max\_diag\_len = min(M + min(k[1], 0), N + min(-k[0], 0))`
         Let `num_diags` be the number of diagonals to extract, :math:`num\_diags = k[1] - k[0] + 1`.
-        If :math:`num\_diags == 1`, the output tensor is of rank r - 1 with shape :math:`[I, J, ..., L, max\_diag\_len]`
-        Otherwise, the output tensor has rank r with dimensions :math:`[I, J, ..., L, num\_diags, max\_diag\_len]`
+        If :math:`num\_diags == 1`, the output tensor is of rank r - 1 with shape :math:`(I, J, ..., L, max\_diag\_len)`
+        Otherwise, the output tensor has rank r with dimensions :math:`(I, J, ..., L, num\_diags, max\_diag\_len)` .
 
     Raises:
         TypeError: If `x` is not Tensor.
@@ -3534,7 +4163,7 @@ def matrix_diag_part(x, k=0, padding_value=0, align="RIGHT_LEFT"):
     return matrix_diag_part_v3(x, k, padding_value)
 
 
-def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):
+def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"): # pylint: disable=redefined-outer-name
     r"""
     Returns a batched matrix tensor with new batched diagonal values.
     Given x and diagonal, this operation returns a tensor with the same shape and values as x, except for the specified
@@ -3544,20 +4173,20 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):
     The diagonal :math:`shape[-1]` must be
     equal to the longest diagonal value max_diag_len calculated
     by :math:`min(x.shape[-2] + min(k[1], 0), x.shape[-1] + min(-k[0], 0))`.
-    Let x have r + 1 dimensions :math:`[I, J, ..., L, M, N]`.
-    The diagonal tensor has rank r with shape :math:`[I, J, ..., L, max\_diag\_len]`
+    Let x have r + 1 dimensions :math:`(I, J, ..., L, M, N)` .
+    The diagonal tensor has rank r with shape :math:`(I, J, ..., L, max\_diag\_len)`
     when k is an integer or :math:`k[0] == k[1]`. Otherwise, it has rank r + 1
-    with shape :math:`[I, J, ... L, num\_diags, max\_diag\_len]`.
+    with shape :math:`(I, J, ... L, num\_diags, max\_diag\_len)` .
 
     Args:
         x (Tensor): Rank r + 1, where r >= 1.
-        diagonal (Tensor): A Tensor. Have the same dtype as x. Rank r when k is an integer or k[0] == k[1].
+        diagonal (Tensor): A Tensor. Have the same dtype as x. Rank r when k is an integer or :math:`k[0] == k[1]`.
             Otherwise, it has rank r + 1.
         k (Union[int, Tensor], optional): A int32 Scalar or int32 Tensor. Diagonal offset(s). Positive value means
             superdiagonal, 0 refers to the main diagonal, and negative value means subdiagonals. k can be a
             single integer (for a single diagonal) or a pair of integers specifying the low and high ends of
             a matrix band. k[0] must not be larger than k[1].
-            The alue of k has restructions, meaning value of k must be in (-x.shape[-2], x.shape[-1]).
+            The alue of k has restructions, meaning value of k must be in :math:`(-x.shape[-2], x.shape[-1])`.
             Input k must be const Tensor when taking Graph mode.
         align (str, optional): An optional string from: "RIGHT_LEFT"(default), "LEFT_RIGHT", "LEFT_LEFT",
             "RIGHT_RIGHT". Align is a string specifying how superdiagonals and subdiagonals should be aligned,
@@ -3565,8 +4194,8 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):
             to the left (right-pads the row).
 
     Returns:
-        Tensor, The same type as x. Let x has r+1 dimensions [I, J, ..., L, M, N].
-        The output is a tensor of rank r+1 with dimensions [I, J, ..., L, M, N], the same as input x.
+        Tensor, The same type as x. Let x has r+1 dimensions :math:`(I, J, ..., L, M, N)` .
+        The output is a tensor of rank r+1 with dimensions :math:`(I, J, ..., L, M, N)` , the same as input x.
 
     Raises:
         TypeError: If input `x` or `diagonal` is not Tensor.
@@ -3579,13 +4208,14 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):
         ValueError: If k[1] is not greater equal to k[0] in case the size of `k` is 2.
         ValueError: If the `diagonal` rank size don't match with input `x` rank size.
         ValueError: If the `diagonal` shape value don't match with input `x` shape value.
-        ValueError: If the diagonal.shape[-2] is not equal to num_diags calculated by k[1] - k[0] + 1.
-        ValueError: If the value of `k` is not in (-x.shape[-2], x.shape[-1]).
-        ValueError: If the diagonal.shape[-1] is not equal to the max_diag_len calculated by min(x.shape[-2] + min(k[1],
-            0), x.shape[-1] + min(-k[0], 0)).
+        ValueError: If the diagonal :math:`shape[-2]` is not equal to num_diags calculated by :math:`k[1]-k[0]+1`.
+        ValueError: If the value of `k` is not in :math:`(-x.shape[-2], x.shape[-1])`.
+        ValueError: If the diagonal.shape[-1] is not equal to the max_diag_len calculated by
+            :math:`min(x.shape[-2] + min(k[1],
+            0), x.shape[-1] + min(-k[0], 0))`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[7, 7, 7, 7],
@@ -3611,7 +4241,7 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):
     return matrix_set_diag_v3_op(x, diagonal, k)
 
 
-def meshgrid(inputs, indexing='xy'):
+def meshgrid(*inputs, indexing='xy'):
     """
     Generates coordinate matrices from given coordinate tensors.
 
@@ -3619,14 +4249,16 @@ def meshgrid(inputs, indexing='xy'):
     coordinate tensors for evaluating expressions on an N-D grid.
 
     Args:
-        inputs (Union[tuple]): A Tuple of N 1-D Tensor objects.
-            The length of input should be greater than 1. The data type is Number.
-        indexing ('xy', 'ij', optional): Cartesian ('xy', default) or
-            matrix ('ij') indexing of output. In the 2-D case with
-            inputs of length `M` and `N`, the outputs are of shape `(N, M)`
-            for 'xy' indexing and `(M, N)` for 'ij' indexing. In the 3-D
+        inputs (List[Tensor]): List of 1-D tensors.
+            The length of inputs should be greater than 1. 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`, the outputs are of shape :math:`(N, M)`
+            for 'xy' indexing and :math:`(M, N)` for 'ij' indexing. In the 3-D
             case with inputs of length `M`, `N` and `P`, outputs are of shape
-            `(N, M, P)` for 'xy' indexing and `(M, N, P)` for 'ij' indexing.
+            :math:`(N, M, P)` for 'xy' indexing and :math:`(M, N, P)` for 'ij' indexing. Default: 'xy'.
 
     Returns:
         Tensors, a Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
@@ -3636,7 +4268,7 @@ def meshgrid(inputs, indexing='xy'):
         ValueError: If `indexing` is neither 'xy' nor 'ij'.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -3645,8 +4277,7 @@ def meshgrid(inputs, indexing='xy'):
         >>> 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))
-        >>> inputs = (x, y, z)
-        >>> output = ops.meshgrid(inputs, indexing='xy')
+        >>> output = ops.meshgrid(x, y, z, indexing='xy')
         >>> print(output)
         (Tensor(shape=[3, 4, 5], dtype=Int32, value=
          [[[1, 1, 1, 1, 1],
@@ -3692,33 +4323,34 @@ def meshgrid(inputs, indexing='xy'):
     return meshgrid_op(inputs)
 
 
-def affine_grid(theta, output_size, align_corners=False):
+def affine_grid(theta, size, align_corners=False):
     r"""
-    Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta.
+    Returns a 2D or 3D flow field (sampling grid) based on `theta`, a batch of affine matrices.
 
     Args:
         theta (Tensor): The input tensor of flow field whose dtype is float16, float32.
-            Input batch of affine matrices with shape [N, 2, 3] for 2D grid or [N, 3, 4] for 3D grid.
-        output_size (tuple[int]): The target output image size.
-            The value of target output with format [N, C, H, W] for 2D grid or [N, C, D, H, W] for 3D grid.
+            Input batch of affine matrices with shape :math:`(N, 2, 3)` for 2D grid or :math:`(N, 3, 4)` for 3D grid.
+        size (tuple[int]): The target output image size.
+            The value of target output with format :math:`(N, C, H, W)` for 2D grid or :math:`(N, C, D, H, W)` for 3D
+            grid.
         align_corners (bool, optional): Geometrically, each pixel of input is viewed as a squqre instead of dot.
             If True, consider extremum -1 and 1 referring to the centers of the pixels rather than pixel corners.
             The default value is False, extremum -1 and 1 refer to the corners of the pixels, so that sampling is
-            irrelevant to resolution of the image.
+            irrelevant to resolution of the image. Default: False.
     Returns:
-        Tensor, a tensor whose data type is same as 'theta', and the shape is [N, H, W, 2] for 2D grid
-        or [N, D, H, W, 3] for 3D grid.
+        Tensor, a tensor whose data type is same as 'theta', and the shape is :math:`(N, H, W, 2)` for 2D grid
+        or :math:`(N, D, H, W, 3)` for 3D grid.
 
     Raises:
-        TypeError: If `theta` is not a Tensor or `output_size` is not a tuple.
-        ValueError: If the shape of `theta` is not [N, 2, 3] or [N, 3, 4].
-        ValueError: If the size of `output_size` is not 4 or 5.
-        ValueError: If the shape of `theta` is [N, 2, 3], the size of `output_size` is not 4;
-                    If the shape of `theta` is [N, 3, 4], the size of `output_size` is not 5.
-        ValueError: If the output_size[0] is not equal to the shape[0] of theta.
+        TypeError: If `theta` is not a Tensor or `size` is not a tuple.
+        ValueError: If the shape of `theta` is not :math:`(N, 2, 3)` or :math:`(N, 3, 4)`.
+        ValueError: If the size of `size` is not 4 or 5.
+        ValueError: If the shape of `theta` is :math:`(N, 2, 3)`, the size of `size` is not 4;
+                    If the shape of `theta` is :math:`(N, 3, 4)`, the size of `size` is not 5.
+        ValueError: If the size[0] is not equal to the shape[0] of theta.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -3736,10 +4368,10 @@ def affine_grid(theta, output_size, align_corners=False):
         [ 0.78333336  0.06666666]]]]
     """
     affine_grid_op = AffineGrid(align_corners)
-    return affine_grid_op(theta, output_size)
+    return affine_grid_op(theta, size)
 
 
-def broadcast_to(x, shape):
+def broadcast_to(input, shape): # pylint: disable=redefined-outer-name
     """
     Broadcasts input tensor to a given shape. The dim of input shape must be smaller
     than or equal to that of target shape. Suppose input shape is :math:`(x_1, x_2, ..., x_m)`,
@@ -3757,6 +4389,8 @@ def broadcast_to(x, shape):
 
     Case 1: If the value of the target shape in the dimension is -1, the value of the
     output shape in the dimension is the value of the corresponding input shape in the dimension.
+    With an input shape :math:`(3, 3)`, target
+    shape :math:`(-1, 3)`, the output shape is :math:`(3, 3)`.
 
     Case 2: If the value of target shape in the dimension is not -1, but the corresponding
     value in the input shape is 1, then the corresponding value of the output shape
@@ -3775,18 +4409,17 @@ def broadcast_to(x, shape):
     input shape :math:`(1, 5, 9)`, the filled input shape will be :math:`(1, 1, 1, 1, 5, 9)` and thus the
     output shape is :math:`(3, 1, 4, 1, 5, 9)`.
 
-    If the first :math:`*` dims of output shape have -1 in it, it implies this -1 is conrresponding to
+    If the first :math:`*` dims of output shape have -1 in it, it implies this -1 is corresponding to
     a non-existing dim so they're not broadcastable. With target shape :math:`(3, -1, 4, 1, 5, 9)`,
     input shape :math:`(1, 5, 9)`, instead of operating the dim-filling process first, it raises errors directly.
 
     Args:
-        x (Tensor): The input tensor.
-                    The shape is :math:`(N,*)` where :math:`*` means,any number of additional dimensions.
+        input (Tensor): The input Tensor. Supported types are: float16, float32, int32, int8, uint8, bool.
         shape (tuple): The target shape to broadcast. Can be fully specified, or have -1 in one position
                        where it will be substituted by the input tensor's shape in that position, see example.
 
     Returns:
-        Tensor, with the given `shape` and the same data type as `x`.
+        Tensor, with the given `shape` and the same data type as `input`.
 
     Raises:
         TypeError: If `shape` is not a tuple.
@@ -3810,8 +4443,11 @@ def broadcast_to(x, shape):
         [[1. 1.]
          [2. 2.]]
     """
+    if isinstance(shape, Tensor) or F.is_sequence_value_unknown(shape):
+        _dyn_broadcast_to = _get_cache_prim(DynamicBroadcastTo)()
+        return _dyn_broadcast_to(input, shape)
     _broadcast_to = _get_cache_prim(P.BroadcastTo)(shape)
-    return _broadcast_to(x)
+    return _broadcast_to(input)
 
 
 def unsorted_segment_min(x, segment_ids, num_segments):
@@ -3960,14 +4596,14 @@ def unsorted_segment_prod(x, segment_ids, num_segments):
     return unsorted_segment_prod_(x, segment_ids, num_segments)
 
 
-def index_fill(x, dim, index, value):
+def index_fill(x, axis, index, value):
     """
-    Fills the elements under the `dim` dimension of the input Tensor `x` with the input `value`
+    Fills the elements under the `axis` dimension of the input Tensor `x` with the input `value`
     by selecting the indices in the order given in `index`.
 
     Args:
         x (Tensor): Input Tensor.  The supported data type is Number or Bool.
-        dim (Union[int, Tensor]): Dimension along which to fill the input Tensor. Only supports
+        axis (Union[int, Tensor]): Dimension along which to fill the input Tensor. Only supports
             an int number or a 0-dimensional Tensor, whose data type is int32 or int64.
         index (Tensor): Indices of the input Tensor to fill in. The dtype must be int32.
         value (Union[bool, int, float, Tensor]): Value to fill the returned Tensor. If `value` is
@@ -3979,20 +4615,20 @@ def index_fill(x, dim, index, value):
 
     Raises:
         TypeError: If `x` 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 `axis` is neither int number nor Tensor.
+        TypeError: When `axis` 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 `x` and `value` are not the same.
-        ValueError: If `dim` is a Tensor and its rank is not equal to 0.
+        ValueError: If `axis` 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]`.
+        RuntimeError: If the value of `axis` is out the range of `[-x.ndim, x.ndim - 1]`.
+        RuntimeError: If the values of `index` are out the range of `[-x.shape[axis], x.shape[axis]-1]`.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -4008,11 +4644,69 @@ def index_fill(x, dim, index, value):
          [-2. 5. -2.]
          [-2. 8. -2.]]
     """
-    if isinstance(dim, int) and not isinstance(dim, bool):
-        dim = cast_(dim, mstype.int32)
+    if isinstance(axis, int) and not isinstance(axis, bool):
+        axis = cast_(axis, mstype.int32)
     if isinstance(value, (bool, float, int)):
         value = cast_(value, x.dtype)
-    return index_fill_(x, dim, index, value)
+    return index_fill_(x, axis, index, value)
+
+
+@constexpr
+def _check_check_axis_in_range(axis, ndim):
+    """Checks axes are with the bounds of ndim"""
+    axis = validator.check_axis_in_range(axis, ndim)
+    return axis
+
+
+def index_select(input, axis, index):
+    """
+    Generates a new Tensor that accesses the values of `input` along the specified `axis` dimension
+    using the indices specified in `index`. The new Tensor has the same number of dimensions as `input`,
+    with the size of the `axis` dimension being equal to the length of `index`, and the size of all other
+    dimensions will be unchanged from the original `input` Tensor.
+
+    .. note::
+        The value of index must be in the range of `[0, input.shape[axis])`, the result is undefined out of range.
+
+    Args:
+        input (Tensor): The input Tensor.
+        axis (int): The dimension to be indexed.
+        index (Tensor): A 1-D Tensor with the indices to access in `input` along the specified axis.
+
+    Returns:
+        Tensor, has the same dtype as input Tensor.
+
+    Raises:
+        TypeError: If `input` or `index` is not a Tensor.
+        TypeError: If `axis` is not int number.
+        ValueError: If the value of `axis` is out the range of `[-input.ndim, input.ndim - 1]`.
+        ValueError: If the dimension of `index` is not equal to 1.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> input = Tensor(np.arange(16).astype(np.float32).reshape(2, 2, 4))
+        >>> print(input)
+        [[[ 0.  1.  2.  3.]
+          [ 4.  5.  6.  7.]]
+         [[ 8.  9. 10. 11.]
+          [12. 13. 14. 15.]]]
+        >>> index = Tensor([0,], mindspore.int32)
+        >>> y = ops.index_select(input, 1, index)
+        >>> print(y)
+        [[[ 0.  1.  2.  3.]]
+         [[ 8.  9. 10. 11.]]]
+    """
+    if not (isinstance(input, Tensor) and isinstance(index, Tensor)):
+        raise TypeError(f"For 'index_select', `input` and `index` must be all tensors.")
+    if index.ndim != 1:
+        raise ValueError(f"For 'index_select', the dimension of `index` must be 1, but got {index.ndim}")
+    axis = _check_check_axis_in_range(axis, input.ndim)
+    return gather_(input, index, axis)
 
 
 def population_count(input_x):
@@ -4049,6 +4743,28 @@ def population_count(input_x):
 ##############################
 
 
+def is_tensor(obj):
+    r"""
+    Check whether the input object is a :class:`mindspore.Tensor` .
+
+    Args:
+        obj (Object): input object.
+
+    Returns:
+        Bool. Return True if `obj` is a Tensor, otherwise, return False.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor([1.9, 2.2, 3.1])
+        >>> ops.is_tensor(a)
+        True
+    """
+    return isinstance(obj, Tensor)
+
+
 def scalar_cast(input_x, input_y):
     """
     Casts the input scalar to another type.
@@ -4101,6 +4817,7 @@ def tensor_scatter_mul(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -4156,6 +4873,7 @@ def tensor_scatter_div(input_x, indices, updates):
     Raises:
         TypeError: If dtype of `indices` is neither int32 nor int64.
         ValueError: If length of shape of `input_x` is less than the last dimension of shape of `indices`.
+        RuntimeError: If a value of `indices` is not in `input_x`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -4175,12 +4893,19 @@ def tensor_scatter_div(input_x, indices, updates):
     return tensor_scatter_div_(input_x, indices, updates)
 
 
+def scalar_to_array(input_x):
+    """
+    The  interface is deprecated. Please use the :func:`mindspore.ops.scalar_to_tensor` instead.
+    """
+    return P.ScalarToArray()(input_x)
+
+
 def scalar_to_tensor(input_x, dtype=mstype.float32):
     """
     Converts a scalar to a `Tensor`, and converts the data type to the specified type.
 
     Args:
-        input_x (Union[int, float]): The input is a scalar. Only constant value is allowed.
+        input_x (Union[bool, int, float]): The input is a scalar. Only constant value is allowed.
         dtype (mindspore.dtype): The target data type. Default: mindspore.float32. Only
             constant value is allowed.
 
@@ -4188,7 +4913,7 @@ def scalar_to_tensor(input_x, dtype=mstype.float32):
         Tensor. 0-D Tensor and the content is the input.
 
     Raises:
-        TypeError: If `input_x` is neither int nor float.
+        TypeError: If `input_x` is neither bool nor int nor float.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4233,23 +4958,27 @@ def tuple_to_array(input_x):
         >>> print(output)
         [1 2 3]
     """
-    return tuple_to_array_(input_x)
+    if isinstance(input_x[0], int):
+        dtype = mstype.int32
+    else:
+        dtype = mstype.float32
+    return tuple_to_tensor_(input_x, dtype)
 
 
-def masked_select(x, mask):
+def masked_select(input, mask):
     """
     Returns a new 1-D Tensor which indexes the `x` tensor according to the boolean `mask`.
     The shapes of the `mask` tensor and the `x` tensor don't need to match, but they must be broadcastable.
 
     Args:
-        x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
         mask (Tensor[bool]): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Returns:
-        A 1-D Tensor, with the same type as `x`.
+        A 1-D Tensor, with the same type as `input`.
 
     Raises:
-        TypeError: If `x` or `mask` is not a Tensor.
+        TypeError: If `input` or `mask` is not a Tensor.
         TypeError: If dtype of `mask` is not bool.
 
     Supported Platforms:
@@ -4265,7 +4994,7 @@ def masked_select(x, mask):
         >>> print(output)
         [1 3]
     """
-    return masked_select_(x, mask)
+    return masked_select_(input, mask)
 
 
 def masked_fill(input_x, mask, value):
@@ -4307,26 +5036,26 @@ def masked_fill(input_x, mask, value):
     return masked_fill_(input_x, mask, value)
 
 
-def diag(input_x):
+def diag(input):
     r"""
     Constructs a diagonal tensor with a given diagonal values.
 
-    Assume `input_x` has dimensions :math:`[D_1,... D_k]`, the output is a tensor of
-    rank 2k with dimensions :math:`[D_1,..., D_k, D_1,..., D_k]` where:
-    :math:`output[i_1,..., i_k, i_1,..., i_k] = input_x[i_1,..., i_k]` and 0 everywhere else.
+    Assume `input` has dimensions :math:`(D_1,... D_k)` , the output is a tensor of
+    rank 2k with dimensions :math:`(D_1,..., D_k, D_1,..., D_k)` where:
+    :math:`output[i_1,..., i_k, i_1,..., i_k] = input[i_1,..., i_k]` and 0 everywhere else.
 
     Args:
-        input_x (Tensor): The input tensor.
+        input (Tensor): The input tensor.
 
     Returns:
-        Tensor, has the same dtype as the `input_x`.
+        Tensor, has the same dtype as the `input`.
 
     Raises:
-        TypeError: If `input_x` is not a Tensor.
-        ValueError: If rank of `input_x` is less than 1.
+        TypeError: If `input` is not a Tensor.
+        ValueError: If rank of `input` is less than 1.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore import Tensor
@@ -4339,7 +5068,58 @@ def diag(input_x):
          [0 0 3 0]
          [0 0 0 4]]
     """
-    return diag_(input_x)
+    return diag_(input)
+
+
+def diagflat(input, offset=0):
+    r"""
+    Create a 2-D Tensor which diagonal is the flattened `input` .
+
+    Args:
+        input (Tensor): Input Tensor, which is flattened and set as the diagonal of the output.
+        offset (int, optional): `offset` controls which diagonal to choose. Default: 0.
+
+            - When `offset` is zero, the diagonal chosen is the main diagonal.
+            - When `offset` is a positive integer, the diagonal chosen is up the main diagonal.
+            - When `offset` is a negative integer, the diagonal chosen is down the main diagonal.
+
+    Returns:
+        The 2-D Tensor, whose diagonal is the flattened `input`.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+        TypeError: If `offset` is not an integer.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([1, 2], mindspore.float32)
+        >>> output = ops.diagflat(x, 1)
+        >>> print(output)
+        [[0. 1. 0.]
+         [0. 0. 2.]
+         [0. 0. 0.]]
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For diagflat, the input x must be tensor, but got {type(input)}")
+    if not isinstance(offset, int):
+        raise TypeError(f"For diagflat, the offset must be int, but got {type(offset)}")
+    offset_abs = abs(offset)
+    if input.size == 0:
+        return zeros((offset_abs, offset_abs), input.dtype)
+    input = input.ravel()
+    res = diag(input)
+    if offset != 0:
+        pad_y = zeros((input.size + offset_abs, offset_abs), input.dtype)
+        pad_x = zeros((offset_abs, input.size), input.dtype)
+        if offset < 0:
+            res = cat((pad_x, res), axis=0)
+            res = cat((res, pad_y), axis=1)
+        else:
+            res = cat((res, pad_x), axis=0)
+            res = cat((pad_y, res), axis=1)
+    return res
 
 
 def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
@@ -4371,7 +5151,7 @@ def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
         ValueError: If input_x.shape[3] does not match the calculated number of sliding blocks.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(input_data=np.random.rand(16, 16, 4, 25), dtype=mstype.float32)
@@ -4384,153 +5164,636 @@ def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
     return c2i(input_x, output_size)
 
 
-def split(input_x, axis=0, output_num=1):
-    r"""
-    Splits the input tensor into output_num of tensors along the given axis and output numbers.
-
-    The `input_x` tensor will be split into equally sized sub-tensors.
-    This requires that `input_x.shape(axis)` is divisible by `output_num`.
+def _split_int(x, split_size_or_sections, axis):
+    """
+    Splits the input tensor `x` into multiple sub-tensors along the axis according to the given `split_size_or_sections`
+    with int type.
+    """
+    arr_shape = x.shape
+    length_along_dim = arr_shape[axis]
+    if split_size_or_sections > length_along_dim:
+        res = P.Split(axis, 1)(x)
+    elif length_along_dim % split_size_or_sections == 0:
+        sections = length_along_dim // split_size_or_sections
+        res = P.Split(axis, sections)(x)
+    else:
+        num_sections = length_along_dim // split_size_or_sections
+        length1 = num_sections * split_size_or_sections
+        length2 = length_along_dim - length1
+        start1 = _list_comprehensions(rank(x), 0, True)
+        size1 = _tuple_setitem(arr_shape, axis, length1)
+        start2 = _tuple_setitem(start1, axis, length1)
+        size2 = _tuple_setitem(arr_shape, axis, length2)
+        res = P.Split(axis, num_sections)(tensor_slice(x, start1, size1)) + \
+              P.Split(axis, 1)(tensor_slice(x, start2, size2))
+    return res
+
+
+def _split_sub_tensors(x, split_size_or_sections, axis):
+    """
+    Splits the input tensor `x` into multiple sub-tensors along the axis according to the given `split_size_or_sections`
+    with type of tuple or list.
+    """
+    new_indices = [0]
+    for i, split_size in enumerate(split_size_or_sections):
+        new_indices.append(new_indices[i] + split_size)
+    new_indices = new_indices[1:]
+    sub_tensors = []
+    strides = _list_comprehensions(x.ndim, 1, True)
+    begin = _list_comprehensions(x.ndim, 0)
+    end = _list_comprehensions(x.shape)
+    for i, idx in enumerate(new_indices):
+        begin[axis] = 0 if i == 0 else new_indices[i - 1]
+        end[axis] = idx
+        sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
+        sub_tensors.append(sliced_tensor)
+    return sub_tensors
+
+
+def split(tensor, split_size_or_sections, axis=0):
+    """
+    Splits the Tensor into chunks along the given axis.
 
     Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-        axis (int): Index of the split position. Default: 0.
-        output_num (int): The number of output tensors. Must be positive int. Default: 1.
+        tensor (Tensor): A Tensor to be divided.
+        split_size_or_sections (Union[int, tuple(int), list(int)]):
+            If `split_size_or_sections` is an int type, `tensor` will be split into equally sized chunks,
+            each chunk with size `split_size_or_sections`. Last chunk will be smaller than `split_size_or_sections`
+            if `tensor.shape[axis]` is not divisible by `split_size_or_sections`.
+            If `split_size_or_sections` is a list type, then `tensor` will be split into len(split_size_or_sections)
+            chunks with sizes `split_size_or_sections` along the given `axis`.
+        axis (int): The axis along which to split. Default: 0.
 
     Returns:
-        tuple[Tensor], the shape of each output tensor is the same, which is
-        :math:`(y_1, y_2, ..., y_S)`. And the data type is the same with `input_x`.
+        A tuple of sub-tensors.
 
     Raises:
-        TypeError: If `axis` or `output_num` is not an int.
-        ValueError: If `axis` is out of the range [-len(`input_x.shape`), len(`input_x.shape`)),
-            or if the `output_num` is less than or equal to 0.
-        ValueError: If `input_x.shape(axis)` is not divisible by `output_num`.
+        TypeError: If argument `tensor` is not Tensor.
+        TypeError: If argument `axis` is not Tensor.
+        ValueError: If argument `axis` is out of range of :math:`[-tensor.ndim, tensor.ndim)` .
+        TypeError: If each element in 'split_size_or_sections' is not integer.
+        TypeError: If argument `indices_or_sections` is not int, tuple(int) or list(int).
+        ValueError: The sum of 'split_size_or_sections' is not equal to x.shape[axis].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]), mindspore.int32)
-        >>> print(x)
-        [[1 1 1 1]
-         [2 2 2 2]]
-        >>> output = ops.split(x, 1, 2)
-        >>> print(output)
-        (Tensor(shape=[2, 2], dtype=Int32, value=
-        [[1, 1],
-         [2, 2]]), Tensor(shape=[2, 2], dtype=Int32, value=
-        [[1, 1],
-         [2, 2]]))
-        >>> output = ops.split(x, 1, 4)
-        >>> print(output)
-        (Tensor(shape=[2, 1], dtype=Int32, value=
-        [[1],
-         [2]]), Tensor(shape=[2, 1], dtype=Int32, value=
-        [[1],
-         [2]]), Tensor(shape=[2, 1], dtype=Int32, value=
-        [[1],
-         [2]]), Tensor(shape=[2, 1], dtype=Int32, value=
-        [[1],
-         [2]]))
-    """
-    split_ = _get_cache_prim(P.Split)(axis, output_num)
-    return split_(input_x)
-
-
-def max(x, axis=0, keep_dims=False):
-    """
-    Calculates the maximum value along with the given axis for the input tensor. It returns the maximum values and
-    indices.
-
-    Note:
-        In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
+        >>> input_x = np.arange(9).astype("float32")
+        >>> 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]),
+         Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    if not isinstance(tensor, Tensor):
+        raise TypeError(f'expect `tensor` is a Tensor, but got {type(tensor)}')
+    if type(axis) is not int:
+        raise TypeError(f"Type of Argument `axis` should be integer but got {type(axis)}")
+    arr_axis = _canonicalize_axis(axis, tensor.ndim)
+
+    if type(split_size_or_sections) is int:
+        if split_size_or_sections > 0:
+            res = _split_int(tensor, split_size_or_sections, arr_axis)
+        else:
+            raise ValueError(f"For split, the value of 'split_size_or_sections' must be more than zero, "
+                             f"but got {split_size_or_sections}.")
+    elif isinstance(split_size_or_sections, (list, tuple)):
+        for item in split_size_or_sections:
+            if type(item) is not int:
+                raise TypeError(f"Each element in 'split_size_or_sections' should be integer, but got {type(item)}.")
+            if item < 0:
+                raise TypeError(f"Each element in 'split_size_or_sections' should be non-negative, "
+                                f"but got {split_size_or_sections}.")
+
+        if sum(split_size_or_sections) != tensor.shape[arr_axis]:
+            raise ValueError(f"The sum of 'split_size_or_sections' should be equal to {tensor.shape[arr_axis]}, "
+                             f"but got {sum(split_size_or_sections)}.")
+        res = _split_sub_tensors(tensor, split_size_or_sections, arr_axis)
+    else:
+        raise TypeError(f"Type of Argument `split_size_or_sections` should be integer, tuple(int) or list(int), " \
+                        f"but got {type(split_size_or_sections)}")
+    return tuple(res)
 
-    .. warning::
-        - If there are multiple maximum values, the index of the first maximum value is used.
-        - The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "x".
 
-    Also see: :class:`mindspore.ops.ArgMaxWithValue`.
+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:
-        x (Tensor): The input tensor, can be any dimension. Set the shape of input tensor as
-          :math:`(x_1, x_2, ..., x_N)`.
-        axis (int): The dimension to reduce. Default: 0.
-        keep_dims (bool): Whether to reduce dimension, if true, the output will keep same dimension with the input,
-                          the output will reduce dimension if false. Default: False.
+        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:
-        tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the maximum value of the input
-        tensor.
-
-        - index (Tensor) - The index for the maximum value of the input tensor, with dtype int32. If `keep_dims`
-          is true, the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
-          Otherwise, the shape is :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
-        - values (Tensor) - The maximum value of input tensor, with the same shape as index, and same dtype as x.
+        Tensor, the same shape and data type as the input `x`.
 
     Raises:
-        TypeError: If `x` is not Tensor.
-        TypeError: If `keep_dims` is not a bool.
-        TypeError: If `axis` is not an int.
+        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:
-        >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-        >>> index, output = ops.max(x)
-        >>> print(index, output)
-        3 0.7
-        >>> index, output = ops.max(x, keep_dims=True)
-        >>> print(index, output)
-        [3] [0.7]
-    """
-    if x.shape == ():
-        return (Tensor(0), x)
-    argmax_with_value_op = ArgMaxWithValue(axis, keep_dims)
-    return argmax_with_value_op(x)
-
-
-def argmax(x, axis=None, keepdims=False):
-    """
-    Return the indices of the maximum values of a tensor across a dimension.
+        >>> 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)
+
+
+def triu(input, diagonal=0): # pylint: disable=redefined-outer-name
+    r"""
+    Returns the upper triangle part of 'input' (elements that contain the diagonal and below),
+    and set the other elements to zeros.
 
     Args:
-        x (Tensor): Input tensor.
-        axis (Union[int, None], optional): The dimension to reduce. If `axis` is None,
-            the indices of the maximum value within the flattened input will be returned.
-            Default: None.
-        keepdims (bool, optional): Whether the output tensor retains the specified
-            dimension. Ignored if `axis` is None. Default: False.
+        input (Tensor): The input tensor with shape :math:`(N,∗)` where ∗ means any number of additional dimensions.
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
+            indicating the main diagonal.
 
     Returns:
-        Tensor, indices of the maximum values across a dimension.
+        Tensor, a tensor has the same shape and data type as input.
 
     Raises:
-        ValueError: If `axis` is out of range.
+        TypeError: If `diagonal` is not an int.
+        TypeError: If `input` is not a Tensor.
+        ValueError: If length of shape of `input` is less than 1.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
-        >>> output = ops.argmax(x, axis=-1)
-        >>> print(output)
-        [1 0 0]
-    """
-    if x.shape == ():
-        return Tensor(0)
-    is_axis_none = False
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.triu(x)
+        >>> print(result)
+        [[ 1  2  3  4]
+         [ 0  6  7  8]
+         [ 0  0 12 13]
+         [ 0  0  0 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.triu(x, diagonal=1)
+        >>> print(result)
+        [[ 0  2  3  4]
+         [ 0  0  7  8]
+         [ 0  0  0 13]
+         [ 0  0  0  0]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.triu(x, diagonal=-1)
+        >>> print(result)
+        [[ 1  2  3  4]
+         [ 5  6  7  8]
+         [ 0 11 12 13]
+         [ 0  0 16 17]]
+    """
+    return _get_cache_prim(P.Triu)(diagonal)(input)
+
+
+@constexpr
+def _canonicalize_axis(axis, ndim):
+    """
+    Check axes are within the number of dimensions of tensor x and normalize the negative axes.
+
+    Args:
+        axis (Union[int, tuple(int), list(int)]): Axes of the tensor.
+        ndim (int): The number of dimensions of the tensor.
+
+    Return:
+        Axis (Union[int, tuple(int)]). If input is integer, return integer, else tuple.
+    """
+    if isinstance(axis, int):
+        axis = [axis]
+    for ax in axis:
+        if not isinstance(ax, int):
+            raise TypeError(f'axis should be integers, not {type(ax)}')
+        if not -ndim <= ax < ndim:
+            raise ValueError(f'axis {ax} is out of bounds for array of dimension {ndim}')
+
+    def canonicalizer(ax):
+        return ax + ndim if ax < 0 else ax
+
+    axis = tuple([canonicalizer(ax) for ax in axis])
+    if all(axis.count(el) <= 1 for el in axis):
+        return tuple(sorted(axis)) if len(axis) > 1 else axis[0]
+    raise ValueError(f"duplicate axis in {axis}.")
+
+
+@constexpr
+def _list_comprehensions(obj, item=None, return_tuple=False):
+    """
+    Generates a new list or tuple by list comprehension.
+
+    Args:
+        obj (Union[int, list, tuple]):
+            If integer, it will be the length of the returned tuple/list.
+        item: The value to be filled. Default: None.
+            If None, the values in the new list/tuple are the same as obj
+            or range(obj) when obj is integer.
+        return_tuple(bool): If true, returns tuple, else returns list.
+
+    Returns:
+        List or tuple.
+    """
+    lst = obj
+    if isinstance(obj, int):
+        lst = np.arange(obj)
+    if item is None:
+        res = list(lst)
+    else:
+        res = [item for _ in lst]
+    if return_tuple:
+        return tuple(res)
+    return res
+
+
+@constexpr
+def _tuple_setitem(tup, idx, value):
+    """
+    Returns a tuple with specified `idx` set to `value`.
+    """
+    tup = list(tup)
+    tup[idx] = value
+    return tuple(tup)
+
+
+def _tensor_split_sub_tensors(x, indices_or_sections, axis):
+    """
+    Splits the input tensor `x` into multiple sub-tensors along the axis according to the given `indices_or_sections`
+    with type of tuple or list.
+    """
+    length_along_dim = x.shape[axis]
+    indices_or_sections = tuple(indices_or_sections)
+    indices_or_sections += (length_along_dim,)
+
+    sub_tensors = []
+    strides = _list_comprehensions(x.ndim, 1, True)
+    begin = _list_comprehensions(x.ndim, 0)
+    end = _list_comprehensions(x.shape)
+    for i, idx in enumerate(indices_or_sections):
+        begin[axis] = 0 if i == 0 else indices_or_sections[i - 1]
+        end[axis] = idx
+        sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
+        sub_tensors.append(sliced_tensor)
+    return tuple(sub_tensors)
+
+
+def _tensor_split_sub_int(x, indices_or_sections, axis):
+    """
+    Splits the input tensor `x` into multiple sub-tensors along the axis according to the given `indices_or_sections`
+    with type if int.
+    """
+    arr_shape = x.shape
+    length_along_dim = arr_shape[axis]
+    if indices_or_sections > length_along_dim:
+        res = P.Split(axis, length_along_dim)(x)
+        indices_or_sections_n = [length_along_dim, length_along_dim + 1]
+        res2 = _tensor_split_sub_tensors(x, indices_or_sections_n, axis)
+        for _ in np.arange(length_along_dim, indices_or_sections):
+            res += tuple(res2)[1:]
+    elif length_along_dim % indices_or_sections == 0:
+        res = P.Split(axis, indices_or_sections)(x)
+    else:
+        num_long_tensor = length_along_dim % indices_or_sections
+        num_short_tensor = indices_or_sections - num_long_tensor
+        length1 = num_long_tensor * (length_along_dim // indices_or_sections + 1)
+        length2 = length_along_dim - length1
+        start1 = _list_comprehensions(rank(x), 0, True)
+        size1 = _tuple_setitem(arr_shape, axis, length1)
+        start2 = _tuple_setitem(start1, axis, length1)
+        size2 = _tuple_setitem(arr_shape, axis, length2)
+        res = P.Split(axis, num_long_tensor)(tensor_slice(x, start1, size1)) + \
+              P.Split(axis, num_short_tensor)(tensor_slice(x, start2, size2))
+    return res
+
+
+def tensor_split(input, indices_or_sections, axis=0):
+    r"""
+    Splits a tensor into multiple sub-tensors along the given axis.
+
+    Args:
+        input (Tensor): A Tensor to be divided.
+        indices_or_sections (Union[int, tuple(int), list(int)]):
+
+            - If `indices_or_sections` is an integer n, input tensor will be split into n sections.
+
+              - If :math:`input.size(axis)` can be divisible by n, sub-sections will have equal size
+                :math:`input.size(axis) / n` .
+              - If :math:`input.size(axis)` is not divisible by n, the first :math:`input.size(axis) % n` sections
+                will have size :math:`x.size(axis) // n + 1` , and the rest will have
+                size :math:`input.size(axis) // n` .
+
+            - If `indices_or_sections` is of type tuple(int) or list(int), the input tensor will be split at the
+              indices in the list or tuple. For example, given parameters :math:`indices\_or\_sections=[1, 4]`
+              and :math:`axis=0` , the input tensor will be split into sections :math:`input[:1]` ,
+              :math:`input[1:4]` , and :math:`input[4:]` .
+
+        axis (int): The axis along which to split. Default: 0.
+
+    Returns:
+        A tuple of sub-tensors.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: If argument `axis` is not int.
+        ValueError: If argument `axis` is out of range of :math:`[-input.ndim, input.ndim)` .
+        TypeError: If each element in 'indices_or_sections' is not integer.
+        TypeError: If argument `indices_or_sections` is not int, tuple(int) or list(int).
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(9).astype("float32")
+        >>> output = ops.tensor_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]),
+        Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
+
+    if type(axis) is not int:
+        raise TypeError(f"Type of Argument `axis` should be integer but got {type(axis)}")
+    handle_axis = _canonicalize_axis(axis, input.ndim)
+    if type(indices_or_sections) is int:
+        if indices_or_sections > 0:
+            res = _tensor_split_sub_int(input, indices_or_sections, handle_axis)
+        else:
+            raise ValueError(f"For tensor_split, the value of 'indices_or_sections' must be more than zero "
+                             f"but got {indices_or_sections}")
+    elif isinstance(indices_or_sections, (list, tuple)):
+        for item in indices_or_sections:
+            if type(item) is not int:
+                raise TypeError(f"Each element in 'indices_or_sections' should be integer, but got {type(item)}.")
+        res = _tensor_split_sub_tensors(input, indices_or_sections, handle_axis)
+    else:
+        raise TypeError(f"Type of Argument `indices_or_sections` should be integer, tuple(int) or list(int), " \
+                        f"but got {type(indices_or_sections)}")
+
+    return res
+
+
+def vsplit(input, indices_or_sections):
+    """
+    Splits `input` with two or more dimensions, into multiple sub-tensors vertically
+    according to `indices_or_sections`.
+
+    It is equivalent to `ops.tensor_split` with :math:`axis=0` .
+
+    Args:
+        input (Tensor): A Tensor to be divided.
+        indices_or_sections (Union[int, tuple(int), list(int)]): See argument in :func:`mindspore.ops.tensor_split`.
+
+    Returns:
+        A list of sub-tensors.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(9).reshape((3, 3)).astype('float32')
+        >>> output = ops.vsplit(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[1, 3], dtype=Float32, value=[[ 0.00000000e+00,  1.00000000e+00,  2.00000000e+00]]),
+         Tensor(shape=[1, 3], dtype=Float32, value=[[ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]]),
+         Tensor(shape=[1, 3], dtype=Float32, value=[[ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]]))
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
+    if input.ndim < 1:
+        raise ValueError(f'vsplit expect `x` is a Tensor with at least 1 dimension, but got {input.ndim}')
+    return tensor_split(input, indices_or_sections, 0)
+
+
+def hsplit(input, indices_or_sections):
+    """
+    Splits a tensor into multiple sub-tensors horizontally.
+    It is equivalent to `ops.tensor_split` with :math:`axis=1` .
+
+    Args:
+        input (Tensor): A Tensor to be divided.
+        indices_or_sections (Union[int, tuple(int), list(int)]): See argument in :func:`mindspore.ops.tensor_split`.
+
+    Returns:
+        A list of sub-tensors.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        ValueError: If dimension of `input` is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(6).reshape((2, 3)).astype('float32')
+        >>> output = ops.hsplit(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[2, 1], dtype=Float32, value=[[ 0.00000000e+00], [ 3.00000000e+00]]),
+         Tensor(shape=[2, 1], dtype=Float32, value=[[ 1.00000000e+00], [ 4.00000000e+00]]),
+         Tensor(shape=[2, 1], dtype=Float32, value=[[ 2.00000000e+00], [ 5.00000000e+00]]))
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
+    if input.ndim < 2:
+        raise ValueError(f'hsplit expect `x` is a Tensor with at least 2 dimension, but got {input.ndim}')
+
+    return tensor_split(input, indices_or_sections, 1)
+
+
+def dsplit(input, indices_or_sections):
+    """
+    Splits a tensor into multiple sub-tensors along the 3rd axis.
+    It is equivalent to `ops.tensor_split` with :math:`axis=2` .
+
+    Args:
+        input (Tensor): A Tensor to be divided.
+        indices_or_sections (Union[int, tuple(int), list(int)]): See argument in :func:`mindspore.ops.tensor_split`.
+
+    Returns:
+        A list of sub-tensors.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(6).reshape((1, 2, 3)).astype('float32')
+        >>> output = ops.dsplit(Tensor(input_x), 3)
+        >>> print(output)
+        (Tensor(shape=[1, 2, 1], dtype=Float32, value=[[[ 0.00000000e+00], [ 3.00000000e+00]]]),
+         Tensor(shape=[1, 2, 1], dtype=Float32, value=[[[ 1.00000000e+00], [ 4.00000000e+00]]]),
+         Tensor(shape=[1, 2, 1], dtype=Float32, value=[[[ 2.00000000e+00], [ 5.00000000e+00]]]))
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'expect `x` is a Tensor, but got {type(input)}')
+    if input.ndim < 3:
+        raise ValueError(f'dsplit expect `x` is a Tensor with at least 3 dimension, but got {input.ndim}')
+
+    return tensor_split(input, indices_or_sections, 2)
+
+
+def _init_and_select_elem(input, initial, where, cmp_fn):    # pylint: disable=redefined-outer-name
+    """Initialize the input according to Initial, and select the element according to where."""
+    if initial is not None:
+        initial = ops.fill(input.dtype, input.shape, initial)
+        input = cmp_fn(input, initial)
+
+    if isinstance(where, Tensor):
+        if initial is None:
+            raise ValueError('initial value must be provided for where masks')
+        where = where.broadcast_to(input.shape)
+        initial = initial.broadcast_to(input.shape)
+        input = ops.select(where, input, initial)
+    return input
+
+
+def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pylint: disable=redefined-outer-name
+    """
+    Calculates the maximum value along with the given axis for the input tensor. It returns the maximum values and
+    indices.
+
+    Note:
+        In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
+
+    .. warning::
+        - If there are multiple maximum values, the index of the first maximum value is used.
+        - The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "input".
+
+    Also see: :class:`mindspore.ops.ArgMaxWithValue`.
+
+    Args:
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        axis (int): The dimension to reduce. Default: 0.
+        keepdims (bool): Whether to reduce dimension, if true, the output will keep same dimension with the input,
+            the output will reduce dimension if false. Default: False.
+
+    Keyword Args:
+        initial (scalar, optional): The minimum value of an output element. Must be present to allow computation
+            on empty slice. Default: None.
+        where (Tensor[bool], optional): A Tensor indicating whether you need to replace the primitive value in 'input'
+            with the initial value. If True, do not replace, if False, replace. The 'where' position is False and the
+            corresponding 'initial' value must be provided. Default value: None, which indicates True by default.
+
+    Returns:
+        tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the maximum value of the input
+        tensor.
+
+        - values (Tensor) - The maximum value of input tensor, with the same shape as index, and same dtype as x.
+        - index (Tensor) - The index for the maximum value of the input tensor, with dtype int32. If `keepdims`
+          is true, the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
+          Otherwise, the shape is :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        TypeError: If `keepdims` is not a bool.
+        TypeError: If `axis` is not an int.
+        TypeError: If `initial` is not a number.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
+        >>> output, index,  = ops.max(x, keepdims=True)
+        >>> print(output, index)
+        0.7 0
+    """
+    if not input.shape:
+        return (input, Tensor(0, dtype=mstype.int32))
     if axis is None:
-        x = reshape_(x, (-1,))
-        axis = 0
-        is_axis_none = True
-    out = P.Argmax(axis, mstype.int64)(x)
-    if keepdims and not is_axis_none:
-        out = expand_dims_(out, axis)
+        return (reduce_max(input), Tensor(0, dtype=mstype.int32))
+    if initial is not None and not isinstance(initial, numbers.Number):
+        raise TypeError(f"For 'max', 'initial' must be a scalar, but got {type(initial)}")
+    if axis is not None and not isinstance(axis, int):
+        raise TypeError(f"For 'max', 'axis' must be int, but got {type(axis)}")
+    input = _init_and_select_elem(input, initial, where, ops.maximum)
+    argmax_with_value_op = ArgMaxWithValue(axis, keepdims)
+    indices, values = argmax_with_value_op(input)
+    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:
+        ValueError: If `dim` is out of range.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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]
+    """
+    if not input.shape:
+        return Tensor(0)
+    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(x, axis=0, keep_dims=False):
+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
     indices.
@@ -4543,68 +5806,77 @@ def min(x, axis=0, keep_dims=False):
         - The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "x".
 
     Args:
-        x (Tensor) - The input tensor, can be any dimension. Set the shape of input tensor as
-          :math:`(x_1, x_2, ..., x_N)` .Complex tensor is not supported.
-        axis (int): The dimension to reduce. Default: 0.
-        keep_dims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
-                          the output will reduce dimension if false. Default: False.
+        input (Tensor): The input tensor, can be any dimension. Complex tensor is not supported for now.
+        axis (int): The dimension to reduce. Default: None.
+        keepdims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
+            the output will reduce dimension if false. Default: False.
+
+    Keyword Args:
+        initial (scalar, optional): The maximum value of an output element. Must be present to allow computation
+            on empty slice. Default: None.
+        where (Tensor[bool], optional): A Tensor indicating whether to replace the primitive value in `input`
+            with the value in `initial`. If True, do not replace, otherwise replace. For the index of True in `where`,
+            the corresponding value in `initial` must be assigned. Default: None, which indicates True by default.
 
     Returns:
         tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the minimum value of the input
         tensor.
 
-        - **index** (Tensor) - The index for the minimum value of the input tensor, with dtype int32. If `keep_dims`
+        - **values** (Tensor) - The minimum value of input tensor, with the same
+          shape as `index`, and same dtype as `x`.
+        - **index** (Tensor) - The index for the minimum value of the input tensor, with dtype int32. If `keepdims`
           is true, the shape of output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
           Otherwise, the shape is :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
-        - **values** (Tensor) - The minimum value of input tensor, with the same shape
-          as `index`, and same dtype as `x`.
 
     Raises:
         TypeError: If `x` is not Tensor.
-        TypeError: If `keep_dims` is not a bool.
+        TypeError: If `keepdims` is not a bool.
         TypeError: If `axis` is not an int.
+        TypeError: If `initial` is not a number.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-        >>> index, output = ops.min(x)
-        >>> print(index, output)
-        0 0.0
-        >>> index, output = ops.min(x, keep_dims=True)
-        >>> print(index, output)
-        [0] [0.0]
+        >>> output, index = ops.min(x, keepdims=True)
+        >>> print(output, index)
+        0.0 0
     """
-    if x.shape == ():
-        return (Tensor(0), x)
-    argmin_with_value_ = ArgMinWithValue(axis=axis, keep_dims=keep_dims)
-    return argmin_with_value_(x)
+    if not input.shape:
+        return (input, Tensor(0, dtype=mstype.int32))
+    if axis is None:
+        return (reduce_min(input), Tensor(0, dtype=mstype.int32))
+    if initial is not None and not isinstance(initial, numbers.Number):
+        raise TypeError(f"For 'min', 'initial' must be a scalar, but got {type(initial)}")
+    if axis is not None and not isinstance(axis, int):
+        raise TypeError(f"For 'min', 'axis' must be int, but got {type(axis)}")
+    input = _init_and_select_elem(input, initial, where, ops.minimum)
+    argmin_with_value_ = ArgMinWithValue(axis=axis, keep_dims=keepdims)
+    indices, values = argmin_with_value_(input)
+    return values, indices
 
 
-def aminmax(x, *, axis=0, keepdims=False):
+def aminmax(input, *, axis=0, keepdims=False):
     """
-    Calculates the minimum value and maximum values.
-
-    Calculates the minimum value and maximum values along with the given axis for the input tensor.
-    It returns the minimum values and maximum values.
-
-    .. warning::
-        - The value range of "axis" is [-rank, rank). "rank" is the dimension length of "x".
+    It returns the minimum and maximum value along the given axis of input tensor.
 
     Args:
-        x (Tensor): The input tensor, can be any dimension. Set the shape of input tensor as
+        input (Tensor): The input tensor, can be any dimension. Set the shape of input tensor as
           :math:`(x_1, x_2, ..., x_N)` .
-        axis (int): The dimension to reduce. Default: 0.
-        keepdims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
-                          the output will reduce dimension if false. Default: False.
+
+    Keyword Args:
+        axis (int, optional): The dimension to reduce. The value range of `axis` is [-rank, rank),
+            where "rank" is the dimension of `input`. Default: 0.
+        keepdims (bool, optional): Whether to maintain dimension. When set to True, the output will keep the same
+            dimension as the input, or the dimension specified by `axis` is reduced. Default: False.
 
     Returns:
-        tuple (Tensor), tuple of 2 tensors, containing the minimum value and maximum value of the input tensor.
+        tuple (Tensor), containing the minimum value and maximum value of the input tensor.
 
-        - If `keepdims` is true, the shape of output tensors is
+        - If `keepdims` is True, the shape of output tensors is
           :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`.
-          Otherwise, the shape is
+        - If `keepdims` is False, the shape of output tensors is
           :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)`.
 
     Raises:
@@ -4613,28 +5885,31 @@ def aminmax(x, *, axis=0, keepdims=False):
         ValueError: If `axis` is not in range [-rank, rank).
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
         >>> output0, output1 = ops.aminmax(x)
         >>> print(output0, output1)
         0.0 0.7
+        >>> output2, output3 = ops.aminmax(x, axis=-1, keepdims=True)
+        >>> print(output2, output3)
+        [0.] [0.7]
     """
     argmin_with_value_op = P.ArgMinWithValue(axis, keepdims)
     argmax_with_value_op = P.ArgMaxWithValue(axis, keepdims)
-    _, output0 = argmin_with_value_op(x)
-    _, output1 = argmax_with_value_op(x)
+    _, output0 = argmin_with_value_op(input)
+    _, output1 = argmax_with_value_op(input)
     return output0, output1
 
 
-def narrow(inputs, axis, start, length):
+def narrow(input, axis, start, length):
     """
     Returns a narrowed tensor from input tensor, and
     the dimension axis is input from start to start + length.
 
     Args:
-        inputs (Tensor): the tensor to narrow.
+        input (Tensor): the tensor to narrow.
         axis (int): the axis along which to narrow.
         start (int): the starting dimension.
         length (int): the distance to the ending dimension.
@@ -4665,15 +5940,15 @@ def narrow(inputs, axis, start, length):
          [ 5 6]
          [ 8 9]]
     """
-    validator.check_axis_in_range(axis, inputs.ndim)
-    validator.check_int_range(start, 0, inputs.shape[axis], Rel.INC_LEFT)
-    validator.check_int_range(length, 1, inputs.shape[axis] - start, Rel.INC_BOTH)
+    validator.check_axis_in_range(axis, input.ndim)
+    validator.check_int_range(start, 0, input.shape[axis], validator.INC_LEFT)
+    validator.check_int_range(length, 1, input.shape[axis] - start, validator.INC_BOTH)
 
-    begins = [0] * inputs.ndim
+    begins = [0] * input.ndim
     begins[axis] = start
-    sizes = [i for i in inputs.shape]
+    sizes = list(input.shape)
     sizes[axis] = length
-    return P.Slice()(inputs, begins, sizes)
+    return P.Slice()(input, begins, sizes)
 
 
 def unsorted_segment_sum(input_x, segment_ids, num_segments):
@@ -4681,7 +5956,8 @@ def unsorted_segment_sum(input_x, segment_ids, num_segments):
     Computes the sum of a tensor along segments.
 
     Calculates a tensor such that :math:`\text{output}[i] = \sum_{segment\_ids[j] == i} \text{data}[j, \ldots]`, where
-    :math:`j` is a tuple describing the index of element in data.  `segment_ids` selects which elements in data to sum
+    :math:`j,...` is a tuple describing the index of element in data.
+    `segment_ids` selects which elements in data to sum
     up. Segment_ids does not need to be sorted, and it does not need to cover all values in the entire valid value
     range.
 
@@ -4732,73 +6008,107 @@ def unsorted_segment_sum(input_x, segment_ids, num_segments):
     return unsorted_segment_sum_(input_x, segment_ids, num_segments)
 
 
-def top_k(input_x, k, sorted=True):
+def topk(input, k, dim=None, largest=True, sorted=True):
     r"""
-    Finds values and indices of the `k` largest entries along the last dimension.
+    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.
+        - 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_x` is a one-dimensional Tensor, finds the `k` largest entries in the Tensor,
-    and outputs its value and index as a Tensor. Therefore, values[`k`] is the `k` largest item in `input_x`,
+    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 `k` entries in each row (corresponding vector along the last dimension), therefore:
+    calculates the first or last `k` entries in a given dimension, therefore:
 
     .. math::
 
-        values.shape = indices.shape = input.shape[:-1] + [k].
+        values.shape = indices.shape
 
     If the two compared elements are the same, the one with the smaller index value is returned first.
 
     Args:
-        input_x (Tensor): Input to be computed, data type must be float16, float32 or int32.
-        k (int): The number of top elements to be computed along the last dimension, constant input is needed.
-        sorted (bool, optional): If true, the obtained elements will be sorted by the values in descending order.
-            Default: True.
+        input (Tensor): Input to be computed, data type must be float16, float32 or int32.
+        k (int): The number of top or bottom elements to be computed along the last dimension, constant input is needed.
+        dim (int, optional): The dimension to sort along. Default: None.
+        largest (bool, optional): If largest is False then the k smallest elements are returned. Default: True.
+        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:
-        Tuple of 2 tensors, the values and the indices.
+        A tuple consisting of `values` and `indexes`.
 
-        - values (Tensor): The `k` largest elements in each slice of the last dimension.
+        - 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_x` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
         TypeError: If `k` is not an int.
-        TypeError: If dtype of `input_x` is not one of the following: float16, float32 or int32.
+        TypeError: If dtype of `input` is not one of the following: float16, float32 or int32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import Tensor
+        >>> import mindspore as ms
         >>> from mindspore import ops
-        >>> import mindspore
-        >>> input_x = Tensor([1, 2, 3, 4, 5], mindspore.float16)
-        >>> k = 3
-        >>> values, indices = ops.top_k(input_x, k, sorted=True)
-        >>> print((values, indices))
-        (Tensor(shape=[3], dtype=Float16, value= [ 5.0000e+00,  4.0000e+00,  3.0000e+00]), Tensor(shape=[3],
-          dtype=Int32, value= [4, 3, 2]))
+        >>> 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(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]]))
     """
     top_k_ = _get_cache_prim(P.TopK)(sorted)
-    return top_k_(input_x, k)
+    if not largest:
+        input = -input
+    if dim is None or dim == input.ndim - 1:
+        if not largest:
+            res = top_k_(input, k)
+            values, indices = -res[0], res[1]
+            return values, indices
+        return top_k_(input, k)
+    input = input.swapaxes(dim, input.ndim - 1)
+    output = top_k_(input, k)
+    values = output[0].swapaxes(dim, input.ndim - 1)
+    indices = output[1].swapaxes(dim, input.ndim - 1)
+    if not largest:
+        res = (-values, indices)
+    else:
+        res = (values, indices)
+    return res
 
 
 def expand(input_x, size):
     r"""
-    Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
+    Returns a new tensor where the dimension of size is expanded to a larger size.
 
     Note:
-        Passing -1 as the `size` for a dimension means not changing the size of that dimension.
-        Tensor can be also expanded to a larger number of dimensions, and the new ones will be appended at the front.
-        For the new dimensions, the `size` cannot be set to -1.
+        - If the `size` for a dimension is -1, it means no change for the size of that dimension.
+        - When a Tensor is expanded to a larger number of dimensions, the new ones will be appended at
+          the front, and for the new dimensions, the `size` can not be -1.
 
     Args:
-        input_x (Tensor): The shape of tensor is (x_1, x_2, ..., x_R).
+        input_x (Tensor): A Tensor to be expanded. The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
         size (Tensor): The expanded shape of `input_x`.
 
     Returns:
@@ -4819,13 +6129,13 @@ def expand(input_x, size):
         ``Ascend`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([[1], [2], [3]]), mindspore.float32)
+        >>> input_x = Tensor(np.array([[2], [3], [4]]), mindspore.float32)
         >>> size = Tensor(np.array([3,4]), mindspore.int32)
         >>> y = ops.expand(input_x, size)
         >>> print(y)
-        [[1. 1. 1. 1.]
-         [2. 2. 2. 2.]
-         [3. 3. 3. 3.]]
+        [[2. 2. 2. 2.]
+         [3. 3. 3. 3.]
+         [4. 4. 4. 4.]]
     """
     expand_op = _get_cache_prim(Expand)()
     return expand_op(input_x, size)
@@ -4836,7 +6146,7 @@ def _check_fold_param(param, param_name):
     """Check the parameters of fold op."""
     validator.check_value_type(param_name, param, [int, list, tuple], 'fold')
     param = (param, param) if isinstance(param, int) else param
-    validator.check(param_name + " size", len(param), "", 2, Rel.EQ, 'fold')
+    validator.check(param_name + " size", len(param), "", 2, validator.EQ, 'fold')
     if param_name == "padding":
         validator.check_non_negative_int_sequence(param, param_name, 'fold')
     else:
@@ -4864,7 +6174,7 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
             for height and width. If type is int, it means that height equal with width. Default: 1.
 
     Returns:
-        A Tensor, with same type as `input` , format of the Tesnor is (N, C, H, W).
+        A Tensor, with same type as `input` , format of the Tensor is (N, C, H, W).
 
     Raises:
         TypeError: If `kernel_size`, `dilation`, `padding`, `stride` data type is not int, tuple or list.
@@ -4875,7 +6185,7 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
         ValueError: If `input.shape[3]` does not match the calculated number of sliding blocks.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(input_data=np.random.rand(16, 16, 4, 25), dtype=mstype.float32)
@@ -4885,9 +6195,9 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
         (16, 16, 8, 8)
     """
     kernel_size = _check_fold_param(kernel_size, "kernel_size")
-    dilation = _check_fold_param(kernel_size, "dilation")
-    padding = _check_fold_param(kernel_size, "padding")
-    stride = _check_fold_param(kernel_size, "stride")
+    dilation = _check_fold_param(dilation, "dilation")
+    padding = _check_fold_param(padding, "padding")
+    stride = _check_fold_param(stride, "stride")
     fold_op = _get_cache_prim(Col2Im)(kernel_size, dilation, padding, stride)
     return fold_op(input, output_size)
 
@@ -4897,7 +6207,7 @@ def _check_unfold_params(param, param_name, param_size):
     """Check the parameters of unfold op."""
     validator.check_value_type(param_name, param, [int, tuple, list], 'unfold')
     param = (param, param) if isinstance(param, int) else param
-    validator.check(param_name + " size", len(param), "", param_size, Rel.IN, 'unfold')
+    validator.check(param_name + " size", len(param), "", param_size, validator.IN, 'unfold')
     if param_name == "padding":
         validator.check_non_negative_int_sequence(param, param_name, 'unfold')
     else:
@@ -4907,8 +6217,8 @@ def _check_unfold_params(param, param_name, param_size):
 
 def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     """
-    Extracts sliding local blocks from a batched input tensor. Format
-    of the input Tensor is (N, C, H, W).
+    Reshapes a tensor of format (N, C, H, W) by extracting sliding local blocks from the input Tensor
+    and concatenating them along a new dimension.
 
     .. warning::
         - Currently, only 4-D input tensors (batched image-like tensors) are supported.
@@ -4920,10 +6230,9 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
         dilation (Union[int, tuple[int], list[int]], optional): The dilation of the window, should be two int
             for height and width. If type is int, it means that height equal with width. Default: 1.
         padding (Union[int, tuple[int], list[int]], optional): The pad of the window, that must be
-            a tuple/list of one or two or four `int` for height and width.
+            a tuple/list of one or two `int` for height and width.
             If one int, pad_height = pad_width.
             If two int, pad_height = padding[0], pad_width = padding[1].
-            If four int, padding = [pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]
             Default: 0.
         stride (Union[int, tuple[int], list[int]], optional): The stride of the window, should be two int
             for height and width. If type is int, it means that height equal with width. Default: 1.
@@ -4938,13 +6247,13 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
         ValueError: If `padding` value is less than zero.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.random.rand(4, 4, 32, 32), mindspore.float16)
+        >>> x = Tensor(np.random.rand(4, 4, 32, 32), mindspore.float64)
         >>> output = ops.unfold(x, kernel_size=3, dilation=1, stride=1)
         >>> print(output.shape)
-        (4, 36, 30, 30)
+        (4, 4, 9, 900)
     """
     kernel_size = _check_unfold_params(kernel_size, "kernel_size", [1, 2])
     dilation = _check_unfold_params(dilation, "dilation", [1, 2])
@@ -4953,7 +6262,6 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     unfold_op = _get_cache_prim(Im2Col)(ksizes=kernel_size,
                                         strides=stride,
                                         dilations=dilation,
-                                        padding_mode="CALCULATED",
                                         pads=padding)
     return unfold_op(input)
 
@@ -4970,11 +6278,10 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     Returns specified diagonals of `input`.
 
     If `input` is 2-D, returns the diagonal of `input` with the given offset.
-    If `a` has more than two
+    If `input` has more than two
     dimensions, then the axes specified by `dim1` and `dim2` are used to determine
-    the 2-D sub-array whose diagonal is returned. The shape of the resulting
-    array can be determined by removing `dim1` and `dim2` and appending an index
-    to the right equal to the size of the resulting diagonals.
+    the 2-D sub-array whose diagonal is returned. In this case, remove the `dim1` and `dim2` dimensions of `input`
+    and insert the last dimension of `input` by the diagonal elements determined by `dim1` and `dim2`.
 
     Args:
         input (Tensor): Array from which the diagonals are taken.
@@ -5027,14 +6334,14 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     elif offset != 0:
         e = e.astype(mstype.float32)
         if offset > 0:
-            e_left = fill_op(dtype, (n, offset), 0)
+            e_left = fill_op(mstype.float32, (n, offset), 0)
             e_right = e[..., 0:m - offset:1]
             e = _get_cache_prim(P.Concat)(1)((e_left, e_right)).astype(dtype)
         elif offset < 0:
-            e_upper = fill_op(dtype, (-offset, m), 0)
+            e_upper = fill_op(mstype.float32, (-offset, m), 0)
             e_lower = e[0:n + offset:1, ...]
             e = _get_cache_prim(P.Concat)(0)((e_upper, e_lower)).astype(dtype)
-    e = _get_cache_prim(P.BroadcastTo)(x_shape)(e)
+    e = F.broadcast_to(e, x_shape)
 
     prod_val = _get_cache_prim(P.Mul)()(input, e)
     res = _get_cache_prim(P.ReduceSum)()(prod_val.astype(mstype.float32), -1)
@@ -5042,7 +6349,7 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     begin = ()
     for _ in np.arange((x_ndim - 2)):
         begin += (0,)
-    last_dim_begin = np.max((0, -offset))
+    last_dim_begin = np.max((0, -offset)).astype(np.int64)
     begin += (last_dim_begin,)
     res_size = res.shape[:-1]
     last_dim_end = np.min((x_shape[-2], np.max((0, (x_shape[-1] - offset))))) - last_dim_begin
@@ -5074,10 +6381,12 @@ def lstsq(input, A):
        \min_y & \|y\|_2 & \text{subject to} & xy = a.
        \end{array}
 
+    where `y` is the returned tensor.
+
     Args:
-        input (Tensor): The m by n matrix equivalent to `x` in above.
+        input (Tensor): The :math:`(m \times n)` matrix equivalent to :math:`x` in above.
             The input tensor whose data type is float16, float32 or float64.
-        A (Tensor): The m by k matrix equivalent to `a` in above.
+        A (Tensor): The :math:`(m \times k)` matrix equivalent to :math:`a` in above.
             The input tensor whose data type is float16, float32 or float64.
 
     Returns:
@@ -5110,18 +6419,18 @@ def lstsq(input, A):
 
 def mvlgamma(input, p):
     r"""
-    Computes the multivariate log-gamma function with dimension `p` element-wise.
+    Returns the results of the multivariate log-gamma function with dimension `p` element-wise.
 
     The mathematical calculation process of Mvlgamma is shown as follows:
 
     .. math::
 
-        \log (\Gamma_{p}(a))=C+\sum_{i=1}^{p} \log (\Gamma(a-\frac{i-1}{2}))
+        \log (\Gamma_{p}(input))=C+\sum_{i=1}^{p} \log (\Gamma(input-\frac{i-1}{2}))
 
     where :math:`C = \log(\pi) \times \frac{p(p-1)}{4}` and :math:`\Gamma(\cdot)` is the Gamma function.
 
     Args:
-        input (Tensor): The tensor to compute the multivariate log-gamma function,
+        input (Tensor): The input tensor of the multivariate log-gamma function,
           which must be one of the following types: float32, float64.
           The shape is :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
           And the value of any element in `input` must be greater than :math:`(p - 1) / 2`.
@@ -5137,7 +6446,7 @@ def mvlgamma(input, p):
         ValueError: If not all elements of `input` are greater than :math:`(p - 1) / 2`.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[3, 4, 5], [4, 2, 6]]), mindspore.float32)
@@ -5150,6 +6459,543 @@ def mvlgamma(input, p):
     return mvlgamma_op(input)
 
 
+def argwhere(input):
+    """
+    Return a Tensor of the positions of all non-zero values.
+
+    Args:
+        input (Tensor): The input tensor. The data type is Number or Bool.
+
+    Returns:
+        Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        ValueError: If dim of `input` equals to 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+        >>> output = ops.argwhere(x)
+        >>> print(output)
+        [[0 0 0]
+         [0 1 0]]
+    """
+    return nonzero_(input)
+
+
+def column_stack(tensors):
+    """
+    Stacks 1-D tensors as columns into a 2-D tensor. 2-D tensors are stacked as-is,
+    like ops.hstack.
+
+    Args:
+        tensors (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. All
+            of them must have the same shape except the axis to be concatenated.
+
+    Returns:
+        2-D Tensor, formed by stacking the given tensors.
+
+    Raises:
+        TypeError: If `tensors` is not Tensor, list or tuple.
+        ValueError: If `tensors` is empty.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor([1, 1, 1])
+        >>> x2 = Tensor([2, 2, 2])
+        >>> output = ops.column_stack((x1, x2))
+        >>> print(output)
+        [[1 2]
+         [1 2]
+         [1 2]]
+    """
+    if not isinstance(tensors, (list, tuple)):
+        raise TypeError(f"For column_stack, the input must be list or tuple or tensor, but got {type(tensors)}.")
+
+    trans_x = ()
+    _expand_dims = _get_cache_prim(P.ExpandDims)()
+    for tensor in tensors:
+        if tensor.ndim < 1:
+            tensor = _expand_dims(tensor, 0)
+        if tensor.ndim == 1:
+            tensor = _expand_dims(tensor, 1)
+        trans_x += (tensor,)
+    if not trans_x:
+        raise ValueError(f"For column_stack, the input must have at least 1 tensor, but got 0.")
+    _concat = _get_cache_prim(P.Concat)(-1)
+    return _concat(trans_x)
+
+
+def hstack(tensors):
+    """
+    Stacks tensors in sequence horizontally.
+    This is equivalent to concatenation along the second axis, except for 1-D tensors
+    where it concatenates along the first axis.
+
+    Args:
+        tensors (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. The
+            tensors must have the same shape along all but the second axis, except
+            1-D tensors which can be any length.
+
+    Returns:
+        Stacked Tensor, formed by stacking the given tensors.
+
+    Raises:
+        TypeError: If `tensors` is not Tensor, list or tuple.
+        ValueError: If `tensors` is empty.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor([1, 1, 1])
+        >>> x2 = Tensor([2, 2, 2])
+        >>> output = ops.hstack((x1, x2))
+        >>> print(output)
+        [1. 1. 1. 2. 2. 2.]
+    """
+    if not isinstance(tensors, (list, tuple)):
+        raise TypeError(f"For hstack, the input must be list or tuple, but got {type(tensors)}.")
+
+    tuple_of_tensor = ()
+    for tensor in tensors:
+        if tensor.ndim < 1:
+            tensor = expand_dims_(tensor, 0)
+        tuple_of_tensor += (tensor,)
+    if not tuple_of_tensor:
+        raise ValueError("For hstack, the input must have at least 1 tensor, but got 0.")
+    if tuple_of_tensor[0].ndim <= 1:
+        _concat = _get_cache_prim(P.Concat)(0)
+        return _concat(tuple_of_tensor)
+    _concat = _get_cache_prim(P.Concat)(1)
+    return _concat(tuple_of_tensor)
+
+
+@constexpr
+def _check_axis_valid(axis, ndim):
+    """
+    Checks axis are valid given ndim, and returns axis that can be passed
+    to the built-in operator (non-negative, int or tuple).
+    """
+    if axis is None:
+        axis = F.make_range(ndim)
+        return axis
+    if isinstance(axis, (tuple, list)):
+        axis = tuple(map(lambda x: _check_check_axis_in_range(x, ndim), axis))
+        return axis
+    return (_check_check_axis_in_range(axis, ndim),)
+
+
+@constexpr
+def _get_moved_perm(ndim, source, destination):
+    """
+    Helper function for movedim, returns permutation after moving axis
+    from source to destination.
+    """
+    dest_sorted_idx = [i for i, _ in sorted(enumerate(destination), key=operator.itemgetter(1))]
+    axis_orig = [i for i in builtins.range(0, ndim) if i not in source]
+
+    k = 0
+    m = 0
+    perm = []
+    for i in dest_sorted_idx:
+        # inserts an axis that has been moved, denoted by n, and axis that remain
+        # in their original position, indexed from k to k + n - m, into index m in
+        # the list of permuted axis
+        n = destination[i]
+        j = k + n - m
+        perm += axis_orig[k:j]
+        perm.append(source[i])
+        k += n - m
+        m = n + 1
+    perm += axis_orig[k:]
+    return tuple(perm)
+
+
+def movedim(x, source, destination):
+    """
+    Moves axis of an array from source to destination.
+
+    Other axis remain in their original order.
+
+    Args:
+        x (Tensor): The tensor array whose axis should be reordered.
+        source (Union[int, sequence[int]]): Original positions of the
+            axis to move. These must be unique.
+        destination (Union[int, sequence[int]]): Destination positions
+            for each of the original axis. These must also be unique.
+
+    Returns:
+        Tensor, array with moved axis.
+
+    Raises:
+        ValueError: If axis are out of the range of `[-a.ndim, a.ndim)`, or
+            if the axis contain duplicates.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> # case1 : moving single axis
+        >>> from mindspore import ops, Tensor
+        >>> import numpy as np
+        >>> x = Tensor(np.zeros((3, 4, 5)))
+        >>> output = ops.movedim(x, 0, -1)
+        >>> print(output.shape)
+        (4, 5, 3)
+        >>> # case 2 : moving multiple axes
+        >>> from mindspore import ops, Tensor
+        >>> import numpy as np
+        >>> x = Tensor(np.zeros((3, 4, 5)))
+        >>> output = ops.movedim(x, (0, 2), (1, 2))
+        >>> print(output.shape)
+        (4, 3, 5)
+    """
+    ndim = F.rank(x)
+    source = _check_axis_valid(source, ndim)
+    destination = _check_axis_valid(destination, ndim)
+    if len(source) != len(destination):
+        raise ValueError(
+            f"For `source` and `destination` arguments, the number of elements must be the same, but got 'source':"
+            f" {len(source)} and 'destination': {len(destination)}.")
+    perm = _get_moved_perm(ndim, source, destination)
+    return _get_cache_prim(P.Transpose)()(x, perm)
+
+
+def moveaxis(x, source, destination):
+    """
+    Alias for `ops.movedim`. Moves axis of an array from source to destination.
+
+    Refer to :func:`mindspore.ops.movedim` for more detail.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops, Tensor
+        >>> import numpy as np
+        >>> x = Tensor(np.zeros((3, 4, 5)))
+        >>> output = ops.moveaxis(x, 0, -1)
+        >>> print(output.shape)
+        (4, 5, 3)
+    """
+
+    return movedim(x, source, destination)
+
+
+@constexpr
+def _check_swapaxes_axis(axes, ndim):
+    return validator.check_swapaxes_axis(axes, ndim)
+
+
+def swapaxes(input, axis0, axis1):
+    '''
+    Interchange two axes of a tensor.
+
+    Args:
+        input(Tensor): Input tensor.
+        axis0 (int): First axis.
+        axis1 (int): Second axis.
+
+    Returns:
+        Transposed tensor, has the same data type as `input`.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: If `axis0` or `axis1` is not integer.
+        ValueError: If `axis0` or `axis1` is not in the range of :math:`[-ndim, ndim-1]`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> 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)
+        >>> print(output.shape)
+        (4,3,2)
+    '''
+    if not isinstance(input, Tensor):
+        raise TypeError(f'For ops.swapaxes, parameter `input` must be Tensor, but got {type(input)}')
+
+    axis0, axis1 = _check_swapaxes_axis((axis0, axis1), input.ndim)
+    if axis0 == axis1:
+        return input
+    if axis0 > axis1:
+        axis0, axis1 = axis1, axis0
+
+    perm = F.make_range(0, input.ndim)
+    if axis1 + 1 < input.ndim:
+        new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
+                   perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1] + perm[axis1 + 1:]
+    else:
+        new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
+                   perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1]
+
+    return _get_cache_prim(P.Transpose)()(input, new_perm)
+
+
+def swapdims(input, dim0, dim1):
+    '''
+    Interchange two dims of a tensor.
+    This function is equivalent to :func:`mindspore.ops.swapaxes` function.
+
+    Args:
+        input(Tensor): Input tensor.
+        dim0 (int): First dim.
+        dim1 (int): Second dim.
+
+    Returns:
+        Transposed tensor, has the same data type as `input`.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: If `dim0` or `dim1` is not integer.
+        ValueError: If `dim0` or `dim1` is not in the range of :math:`[-ndim, ndim-1]`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> 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)
+        >>> print(output.shape)
+        (4,3,2)
+    '''
+    return F.swapaxes(input, dim0, dim1)
+
+
+@constexpr
+def _check_is_int(arg_value, arg_name, op_name):
+    arg_value = validator.check_is_int(arg_value, arg_name, op_name)
+    return arg_value
+
+
+@constexpr
+def _check_positive_int(arg_value, arg_name, op_name):
+    arg_value = validator.check_positive_int(arg_value, arg_name, op_name)
+    return arg_value
+
+
+@constexpr
+def _check_axis_range(arg_value, limit, arg_name, op_name):
+    arg_value = validator.check_int_range(arg_value, -limit, limit, validator.INC_LEFT, arg_name, op_name)
+    return arg_value
+
+
+@_primexpr
+def _cal_repeat_dims(x_rank, rep, expand_axis):
+    rep_dims = [1] * (x_rank + 1)
+    rep_dims[expand_axis] = rep
+    return tuple(rep_dims)
+
+
+@constexpr
+def _cal_reshape(x_shape, rep, axis):
+    x_reshape = list(x_shape)
+    x_reshape[axis] *= rep
+    return tuple(x_reshape)
+
+
+def repeat_interleave(input, repeats, axis=None):
+    """
+    Repeat elements of a tensor along an axis, like `numpy.repeat`.
+
+    Args:
+        input (Tensor): The tensor to repeat values for. Must be of type: float16,
+            float32, int8, uint8, int16, int32, or int64.
+        repeats (int): The number of times to repeat, must be positive.
+        axis (int, optional): The axis along which to repeat, default: None. if dims is None, the input Tensor will be
+            flattened and the output will alse be flattened.
+
+    Returns:
+        One tensor with values repeated along the specified axis. If input has shape
+        :math:`(s1, s2, ..., sn)` and axis is i, the output will have shape :math:`(s1, s2, ...,
+        si * repeats, ..., sn)`. The output type will be the same as the type of `input`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
+        >>> output = ops.repeat_interleave(input, repeats=2, axis=0)
+        >>> print(output)
+        [[0 1 2]
+         [0 1 2]
+         [3 4 5]
+         [3 4 5]]
+    """
+    if axis is None:
+        input = input.reshape(-1)
+        axis = 0
+    return repeat_elements(input, repeats, axis)
+
+
+def repeat_elements(x, rep, axis=0):
+    """
+    Repeat elements of a tensor along an axis, like `np.repeat` .
+
+    Args:
+        x (Tensor): The tensor to repeat values for. Must be of type: float16,
+            float32, int8, uint8, int16, int32, or int64.
+        rep (int): The number of times to repeat, must be positive.
+        axis (int): The axis along which to repeat, default 0.
+
+    Returns:
+        One tensor with values repeated along the specified axis. If x has shape
+        :math:`(s1, s2, ..., sn)` and axis is i, the output will have shape :math:`(s1, s2, ..., si * rep, ..., sn)`.
+        The output type will be the same as the type of `x`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> # case 1 : repeat on axis 0
+        >>> x = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
+        >>> output = ops.repeat_elements(x, rep = 2, axis = 0)
+        >>> print(output)
+        [[0 1 2]
+         [0 1 2]
+         [3 4 5]
+         [3 4 5]]
+        >>> # case 2 : repeat on axis 1
+        >>> x = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
+        >>> output = ops.repeat_elements(x, rep = 2, axis = 1)
+        >>> print(output)
+        [[0 0 1 1 2 2]
+         [3 3 4 4 5 5]]
+    """
+    const_utils.check_type_valid(F.dtype(x), mstype.number_type, 'input x')
+    rep = _check_positive_int(rep, "rep", "repeat_elements")
+    axis = _check_is_int(axis, "axis", "repeat_elements")
+    shape_op = P.Shape()
+    rank_op = P.Rank()
+    tile_op = P.Tile()
+    expand_dims_op = P.ExpandDims()
+    reshape_op = P.Reshape()
+    x_rank = rank_op(x)
+    axis = _check_axis_range(axis, x_rank, "axis", "repeat_elements")
+    expand_axis = axis + 1
+    x_expand = expand_dims_op(x, expand_axis)
+    rep_dims = _cal_repeat_dims(x_rank, rep, expand_axis)
+    x_expand = tile_op(x_expand, rep_dims)
+    x_shape = shape_op(x)
+    x_reshape = _cal_reshape(x_shape, rep, axis)
+    x_rep = reshape_op(x_expand, x_reshape)
+    return x_rep
+
+
+@_primexpr
+def _check_sequence_mask_input_len(input_shape, prim_name=None):
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
+    if not input_shape:
+        raise ValueError(f"{msg_prefix} input_shape must be greater than 0, but got {input_shape}.")
+    # broadcast only supports 7d shape
+    shape_size = len(input_shape)
+    if shape_size >= 7:
+        raise ValueError(f"{msg_prefix} dimension of input_shape must be less than 7, but got {shape_size}d.")
+
+
+def sequence_mask(lengths, maxlen=None):
+    """
+    Returns a mask tensor representing the first N positions of each cell.
+
+    If `lengths` has shape :math:`(d_1, d_2, ..., d_n)`, then the resulting tensor mask has type and shape
+    :math:`(d_1, d_2, ..., d_n, maxlen)`, with mask :math:`[i_1, i_2, ..., i_n, j] = (j < lengths[i_1, i_2, ..., i_n])`.
+
+    Args:
+        lengths (Tensor): Tensor to calculate the mask for. All values in this tensor should be
+            less than or equal to `maxlen`. Values greater than `maxlen` will be treated as `maxlen`.
+        maxlen (int): size of the last dimension of returned tensor. Must be positive and same
+            type as elements in `lengths`. Default is None.
+
+    Returns:
+        One mask tensor of shape `lengths.shape + (maxlen,)` .
+
+    Raises:
+        TypeError: If `lengths` is not a Tensor.
+        TypeError: If `maxlen` is not an int.
+        TypeError: If dtype of `lengths` is neither int32 nor int64.
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> # case 1: When maxlen is assigned
+        >>> x = Tensor(np.array([1, 2, 3, 4]))
+        >>> output = ops.sequence_mask(x, 5)
+        >>> print(output)
+        [[ True False False False False]
+         [ True  True False False False]
+         [ True  True  True False False]
+         [ True  True  True  True False]]
+        >>> # case 2: When there is 0 in x
+        >>> x = Tensor(np.array([[1, 3], [2, 0]]))
+        >>> output = ops.sequence_mask(x, 5)
+        >>> print(output)
+        [[[ True False False False False]
+          [ True  True  True False False]]
+         [[ True  True False False False]
+          [False False False False False]]]
+        >>> # case 3: when the maxlen is not assigned
+        >>> x = Tensor(np.array([[1, 3], [2, 4]]))
+        >>> output = ops.sequence_mask(x)
+        >>> print(output)
+        [[[ True False False False ]
+          [ True  True  True False ]]
+         [[ True  True False False ]
+          [ True  True  True  True ]]]
+    """
+
+    argmax_op = P.ArgMaxWithValue()
+    reshape_op = P.Reshape()
+    range_op = P.Range()
+    expand_op = P.ExpandDims()
+    cast_op = P.Cast()
+    to_tensor_op = P.ScalarToTensor()
+    shape_op = P.Shape()
+
+    const_utils.check_type_valid(F.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
+    _check_sequence_mask_input_len(shape_op(lengths), "sequence_mask")
+
+    if maxlen is None:
+        flatten_data = reshape_op(lengths, (-1,))
+        flatten_data = cast_op(flatten_data, mstype.float32)
+        _, value = argmax_op(flatten_data)
+        maxlen = cast_op(value, mstype.int32)
+    else:
+        maxlen = _check_positive_int(maxlen, "maxlen", "sequence_mask")
+        maxlen = to_tensor_op(maxlen, mstype.int32)
+
+    range_vector = range_op(to_tensor_op(0, mstype.int32), maxlen, to_tensor_op(1, mstype.int32))
+    mask = expand_op(lengths, -1)
+    result = range_vector < mask
+    return result
+
+
+def top_k(input_x, k, sorted=True):
+    r"""
+    `top_k` is deprecated, please use `ops.topk` instead.
+    """
+    top_k_ = _get_cache_prim(P.TopK)(sorted)
+    return top_k_(input_x, k)
+
+
 __all__ = [
     'unique',
     'unique_with_pad',
@@ -5165,10 +7011,16 @@ __all__ = [
     'ger',
     'ones',
     'ones_like',
+    'zeros',
+    'zeros_like',
     'shape',
     'shape_',
     'reverse',
     'reverse_sequence',
+    'hamming_window',
+    'chunk',
+    'full',
+    'full_like',
     'dyn_shape',
     'rank',
     'range',
@@ -5179,11 +7031,14 @@ __all__ = [
     'tensor_slice',
     'strided_slice',
     'slice',
+    'cat',
     'concat',
     'stack',
     'unbind',
     'unstack',
+    'is_tensor',
     'scalar_cast',
+    'scalar_to_array',
     'scalar_to_tensor',
     'space_to_batch_nd',
     'batch_to_space_nd',
@@ -5206,6 +7061,7 @@ __all__ = [
     'tensor_scatter_max',
     'tensor_scatter_min',
     'tensor_scatter_elements',
+    'scatter',
     'unsorted_segment_min',
     'unsorted_segment_max',
     'unsorted_segment_prod',
@@ -5216,7 +7072,9 @@ __all__ = [
     'one_hot',
     'masked_fill',
     'masked_select',
+    'where',
     'narrow',
+    'ravel',
     'scatter_add',
     'scatter_mul',
     'scatter_max',
@@ -5224,29 +7082,52 @@ __all__ = [
     'scatter_div',
     'scatter_update',
     'select',
+    'tril',
+    'triu',
     'nonzero',
     'matrix_diag',
     'matrix_diag_part',
     'matrix_set_diag',
     'diag',
+    'diagflat',
     'meshgrid',
     'affine_grid',
     'meshgrid',
     'broadcast_to',
     'col2im',
     'split',
-    "index_fill",
+    'tensor_split',
+    'vsplit',
+    'hsplit',
+    'dsplit',
+    'index_fill',
+    'index_select',
     'max',
     'argmax',
     'min',
     'unsorted_segment_sum',
     'population_count',
-    'top_k',
+    'topk',
     'expand',
     'fold',
     'unfold',
     'diagonal',
     'lstsq',
     'mvlgamma',
+    'swapaxes',
+    'swapdims',
+    'searchsorted',
+    'argsort',
+    'sequence_mask',
+    'repeat_elements',
+    'repeat_interleave',
+    'argwhere',
+    'column_stack',
+    'hstack',
+    'movedim',
+    'moveaxis',
+    'aminmax',
+    'sort',
+    'top_k'
 ]
 __all__.sort()