mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/function/array_func.py

@@ -26,11 +26,11 @@ 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
+import mindspore.ops as ops
 from mindspore.ops.operations._inner_ops import DynamicBroadcastTo
 from mindspore.ops.operations._sequence_ops import TupleToTensor
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
+from mindspore.ops.operations._sequence_ops import TensorToList
 
 from mindspore.ops.operations.array_ops import (
     UniqueConsecutive,
@@ -59,11 +59,11 @@ from mindspore.common import Tensor
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as validator
 from mindspore._c_expression import Tensor as Tensor_
+from mindspore.ops._utils.utils import ms_arrange
 
 tuple_to_tensor_ = TupleToTensor()
 eye_ = P.Eye()
 fills_ = Fills()
-fill_ = P.Fill()
 ones_ = P.Ones()
 ones_like_ = P.OnesLike()
 tile_ = P.Tile()
@@ -112,9 +112,9 @@ reduce_min = P.ReduceMin()
 
 @_primexpr
 def get_x_shape(x_shape):
-    if F.is_sequence_shape_unknown(x_shape):
+    if ops.is_sequence_shape_unknown(x_shape):
         return (-2,)
-    if F.is_sequence_value_unknown(x_shape):
+    if ops.is_sequence_value_unknown(x_shape):
         return (-1,)
     s = 1
     for i in x_shape:
@@ -148,7 +148,7 @@ def _get_type(x):
     """get the dtype of input"""
     if isinstance(x, Tensor):
         return x.dtype
-    return F.typeof(x)
+    return ops.typeof(x)
 
 
 def _get_max_type(start, end, step):
@@ -178,16 +178,16 @@ def arange(start=0, end=None, step=1, *, dtype=None):
 
     Args:
         start (Union[float, int, Tensor], optional): The start of the interval.
-            If Tensor, the shape must be (). Default: 0.
+            If Tensor, the shape must be :math:`()` . Default: ``0`` .
         end (Union[float, int, Tensor], optional): The end of the interval, exclusive.
-            If Tensor, the shape must be ().
-            Default: None. If None, it defaults to the value of `start`, and 0 is used as the starting value.
+            If Tensor, the shape must be :math:`()`.
+            Default: ``None`` . If ``None`` , it defaults to the value of `start`, and 0 is used as the starting value.
         step (Union[float, int, Tensor], optional): Number that increments `start`.
-            If Tensor, the shape must be (). Default: 1.
+            If Tensor, the shape must be :math:`()`. Default: ``1`` .
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The required data type of returned Tensor. Default: None.
-            If the value is not specified or is None, the type with the highest precision in the
+        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:
@@ -237,7 +237,8 @@ def arange(start=0, end=None, step=1, *, dtype=None):
     if start.shape != () or end.shape != () or step.shape != ():
         raise ValueError(f"For arange, the input args must be a TensorScalar,"
                          f" but got start shape:{start.shape}, end shape:{end.shape}, step shape:{step.shape}")
-    data = P.Range()(start, end, step)
+    range_op = _get_cache_prim(P.Range)()
+    data = range_op(start, end, step)
     if dtype is not None:
         data = cast_(data, dtype)
     return data
@@ -263,7 +264,7 @@ def cat(tensors, axis=0):
             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.
+        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)`.
@@ -279,6 +280,9 @@ def cat(tensors, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> input_x2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> output = ops.cat((input_x1, input_x2))
@@ -307,10 +311,10 @@ def eye(n, m=None, dtype=None):
     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.
-            Default: if None, the number of columns is as the same as n.
+            Default: ``None`` , if ``None`` , the number of columns is as the same as n.
         dtype (mindspore.dtype): MindSpore's dtype, the data type of the returned tensor.
             The data type can be bool or Number.
-            Default: None, the data type of the returned tensor is mindspore.float32.
+            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
@@ -318,12 +322,14 @@ def eye(n, m=None, dtype=None):
 
     Raises:
         TypeError: If `m` or `n` is not an int.
-        ValueError: If `m` or `n` is less than 1.
+        ValueError: If `m` or `n` is less than 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> output = ops.eye(2, 2, mindspore.int32)
         >>> print(output)
         [[1 0]
@@ -368,11 +374,12 @@ def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype
     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 β.
+            Default: ``True`` .
+        alpha (float, optional): The coefficient α. Default: ``0.54`` .
+        beta (float, optional): The coefficient β. Default: ``0.46`` .
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The output window data type. Default: None.
+        dtype (mindspore.dtype, optional): The output window data type. Default: ``None`` .
 
     Returns:
         Tensor, a 1-D tensor of size (window_length) containing the window.
@@ -385,12 +392,13 @@ def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> 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)}.")
+                        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):
@@ -404,14 +412,11 @@ def hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype
     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
+    dtype = mstype.float32 if dtype is None else dtype
+    op = _get_cache_prim(P.HammingWindow)(periodic, alpha, beta, dtype)
+    length = Tensor(np.array([window_length]).astype(np.int32))
+    out = op(length)
+    return out
 
 
 def where(condition, x, y):
@@ -438,6 +443,9 @@ def where(condition, x, y):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> a = Tensor(np.arange(4).reshape((2, 2)), mstype.float32)
         >>> b = Tensor(np.ones((2, 2)), mstype.float32)
         >>> condition = a < 3
@@ -450,13 +458,15 @@ def where(condition, x, y):
         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)}.")
+            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)}.")
+            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)
@@ -474,7 +484,7 @@ def reverse(x, axis):
         The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "input_x".
 
     Args:
-        x (Tensor): The target tensor. The data type is Number except float64.
+        x (Tensor): The target tensor.
             The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         axis (Union[tuple(int), list(int)]): The indices of the dimensions to reverse.
 
@@ -489,6 +499,9 @@ def reverse(x, axis):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
         >>> output = ops.reverse(input_x, axis=[1])
         >>> print(output)
@@ -520,6 +533,8 @@ def ravel(input):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> output = ops.ravel(x)
         >>> print(output)
@@ -534,9 +549,11 @@ def matrix_band_part(x, lower, upper):
     r"""
     Copy a tensor setting everything outside a central band in each innermost matrix to zero.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         x (Tensor): Input tensor. :math:`(*, m, n)` where :math:`*` means, any number of additional dimensions.
-            The data type must be float16, float32, float64, int32 or int64.
         lower (Union[int, Tensor]): Number of subdiagonals to keep. The data type must be int32 or int64.
             If negative, keep entire lower triangle.
         upper (Union[int, Tensor]): Number of superdiagonals to keep. The data type must be int32 or int64.
@@ -547,7 +564,7 @@ def matrix_band_part(x, lower, upper):
 
     Raises:
         TypeError: If `x` is not a Tensor.
-        TypeError: If dtype of `x` is not one of float16, float32, float64, int32 or int64.
+        TypeError: If dtype of `x` is not valid.
         TypeError: If `lower` is neither a number nor a Tensor.
         TypeError: If `upper` is neither a number nor a Tensor.
         TypeError: If dtype of `lower` is neither int32 nor int64.
@@ -557,9 +574,11 @@ def matrix_band_part(x, lower, upper):
         ValueError: If the shape of `upper` is not equal to 0D.
 
     Supported Platforms:
-
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.ones([2, 4, 4]).astype(np.float32))
         >>> output = ops.matrix_band_part(x, 2, 1)
         >>> print(output)
@@ -582,7 +601,8 @@ def padding(x, pad_dim_size=8):
     Args:
         x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The rank of `x` must be at least 2.
             The last dimension of `x` must be 1. The data type is Number.
-        pad_dim_size (int): The value of the last dimension of `x` to be extended, which must be positive. Default: 8.
+        pad_dim_size (int): The value of the last dimension of `x` to be extended, which must be positive.
+            Default: ``8`` .
 
     Returns:
         Tensor, has the same type and shape as input shape value.
@@ -596,6 +616,9 @@ def padding(x, pad_dim_size=8):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8], [10]]), mindspore.float32)
         >>> pad_dim_size = 4
         >>> output = ops.padding(x, pad_dim_size)
@@ -628,7 +651,7 @@ def _check_axis_type(axis, type_int=True, type_tuple=True, type_list=True, ops_n
     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):
+def one_hot(indices, depth, on_value=1, off_value=0, axis=-1):
     r"""
     Computes a one-hot tensor.
 
@@ -640,24 +663,24 @@ def one_hot(indices, depth, on_value, off_value, axis=-1):
 
     Args:
         indices(Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
-            Data type must be uint8, int32 or int64.
+            Data type must be int32 or int64.
         depth(int): A scalar defining the depth of the one-hot dimension.
-        on_value(Union[Tensor, int, float]): A value to fill in output when `indices[j] = i`.
+        on_value(Union[Tensor, int, float], optional): 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(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,
+            bool, complex64, complex128. Default: ``1`` .
+        off_value(Union[Tensor, int, float], optional): A value to fill in output when `indices[j] != i`.
+            Has the same data type as `on_value`. Default: ``0`` .
+        axis(int, optional): 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, depth)`, If `axis` is 0,
             the output shape will be :math:`(depth, N, C)`.
-            Default: -1.
+            Default: ``-1`` .
 
     Returns:
         Tensor, one-hot tensor. Tensor of shape :math:`(X_0, \ldots, X_{axis}, \text{depth} ,X_{axis+1}, \ldots, X_n)`.
 
     Raises:
         TypeError: If `axis` or `depth` is not an int.
-        TypeError: If dtype of `indices` is not uint8, int32 or int64.
+        TypeError: If dtype of `indices` is not int32 or int64.
         TypeError: If `indices`, `on_value` or `off_value` is not a Tensor.
         ValueError: If `axis` is not in range [-1, ndim].
         ValueError: If `depth` is less than 0.
@@ -666,6 +689,9 @@ def one_hot(indices, depth, on_value, off_value, axis=-1):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> indices = Tensor(np.array([0, 1, 2]), mindspore.int32)
         >>> depth, on_value, off_value = 3, Tensor(1.0, mindspore.float32), Tensor(0.0, mindspore.float32)
         >>> output = ops.one_hot(indices, depth, on_value, off_value, axis=-1)
@@ -688,8 +714,8 @@ def fill(type, shape, value):  # pylint: disable=redefined-outer-name
 
     Args:
         type (mindspore.dtype): The specified type of output tensor. The data type only supports
-            `bool_ <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ and
-            `number <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ .
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ and
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
         shape (Union(Tensor, tuple[int])): The specified shape of output tensor.
         value (Union(Tensor, number.Number, bool)): Value to fill the returned tensor.
 
@@ -703,6 +729,8 @@ def fill(type, shape, value):  # pylint: disable=redefined-outer-name
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> output = ops.fill(mindspore.float32, (2, 2), 1)
         >>> print(output)
         [[1. 1.]
@@ -713,10 +741,11 @@ def fill(type, shape, value):  # pylint: disable=redefined-outer-name
          [0. 0. 0.]
          [0. 0. 0.]]
     """
-    return fill_(type, shape, value)
+    value = cast_(value, type)
+    return _get_cache_prim(P.FillV2)()(shape, value)
 
 
-def full(size, fill_value, *, dtype=None): # pylint: disable=redefined-outer-name
+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.
 
@@ -726,7 +755,7 @@ def full(size, fill_value, *, dtype=None): # pylint: disable=redefined-outer-nam
 
     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.
+            please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
         Tensor.
@@ -739,6 +768,7 @@ def full(size, fill_value, *, dtype=None): # pylint: disable=redefined-outer-nam
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
         >>> output = ops.full((2, 2), 1)
         >>> print(output)
         [[1. 1.]
@@ -757,7 +787,7 @@ def full(size, fill_value, *, dtype=None): # pylint: disable=redefined-outer-nam
         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)
+    return ops.fill(dtype, size, fill_value)
 
 
 def full_like(input, fill_value, *, dtype=None):
@@ -770,7 +800,7 @@ def full_like(input, fill_value, *, dtype=None):
 
     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.
+            for details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
         Tensor.
@@ -782,6 +812,8 @@ def full_like(input, fill_value, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
         >>> output = ops.full_like(input, 1)
         >>> print(output)
@@ -806,12 +838,12 @@ 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!
+        This function may return less than the specified number of chunks!
 
     Args:
         input (Tensor): A Tensor to be cut.
         chunks (int): Number of sub-tensors to cut.
-        axis (int, optional): Specify the dimensions that you want to split. Default: 0.
+        axis (int, optional): Specify the dimensions that you want to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -827,6 +859,8 @@ def chunk(input, chunks, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import ops, Tensor
         >>> input_x = np.arange(9).astype("float32")
         >>> output = ops.chunk(Tensor(input_x), 3)
         >>> print(output)
@@ -876,12 +910,12 @@ def fills(x, value):
         value_ = float(value)
     elif isinstance(value, Tensor):
         if value.ndim != 0:
-            raise ValueError("For 'ops.fills', if the argument 'value' is a tensor, the number of its dimension"
-                             " should be 0, but got {}".format(value.ndim))
+            raise ValueError(f"For 'ops.fills', if the argument 'value' is a tensor, the number of its dimension"
+                             f" should be 0, but got {value.ndim}")
         value_ = value.astype(mstype.float32)
     else:
-        raise TypeError("For 'ops.fills', the type of argument 'value' should be int, float or Tensor,"
-                        " but got {}".format(type(value)))
+        raise TypeError(f"For 'ops.fills', the type of argument 'value' should be int, float or Tensor,"
+                        f" but got {type(value)}")
     return fills_(x, value_)
 
 
@@ -893,38 +927,39 @@ def ones(shape, dtype=None):  # pylint: disable=redefined-outer-name
     argument.
 
     Args:
-        shape (Union[tuple[int], int]): The specified shape of output tensor. Only constant positive int is allowed.
-        dtype (:class:`mindspore.dtype`): The specified type of output tensor. If `dtype` is None,
-            `mindspore.float32` will be used. Default: None.
+        shape (Union[tuple[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
+            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
+            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
+        dtype (:class:`mindspore.dtype`): The specified type of output tensor. If `dtype` is ``None`` ,
+            `mindspore.float32` will be used. Default: ``None`` .
 
     Returns:
         Tensor, has the same type and shape as input shape value.
 
     Raises:
-        TypeError: If `shape` is neither tuple nor int.
+        TypeError: If `shape` is not tuple, int or Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> output = ops.ones((2, 2), mindspore.float32)
         >>> print(output)
         [[1. 1.]
          [1. 1.]]
     """
     _dtype = mstype.float32 if dtype is None else dtype
-    ones_op = P.FillV2()
+    ones_op = _get_cache_prim(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)
+    elif isinstance(shape, list):
+        shape = Tensor(shape, dtype=mstype.int64)
+    elif isinstance(shape, Tensor) and shape.ndim == 0 and shape.size == 1:
+        shape = shape.reshape(1)
+    output = ones_op(shape, value)
     return output
 
 
@@ -936,8 +971,8 @@ def ones_like(input, *, dtype=None):
         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.
+        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 as `input` but filled with ones.
@@ -949,13 +984,15 @@ def ones_like(input, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
         >>> output = ops.ones_like(x)
         >>> print(output)
         [[1 1]
          [1 1]]
     """
-    ones_like_op = P.OnesLike()
+    ones_like_op = _get_cache_prim(P.OnesLike)()
     output = ones_like_op(input)
     _dtype = input.dtype if dtype is None else dtype
     output = cast_(output, _dtype)
@@ -967,38 +1004,39 @@ def zeros(size, dtype=None):  # pylint: disable=redefined-outer-name
     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.
+        size (Union[tuple[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
+            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
+            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
+            mindspore.float32 will be used. Default: ``None`` .
 
     Returns:
         Tensor, has the same dtype and size as input.
 
     Raises:
-        TypeError: If `size` is neither a tuple of int nor an int.
+        TypeError: If `size` is not tuple, int or Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> output = ops.zeros((2, 2), mindspore.float32)
         >>> print(output)
         [[0. 0.]
          [0. 0.]]
     """
-    zero_op = P.FillV2()
+    zero_op = _get_cache_prim(P.FillV2)()
     _dtype = mstype.float32 if dtype is None else dtype
     value = Tensor(0, _dtype)
     if isinstance(size, int):
         size = tuple([size])
-    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)
+    elif isinstance(size, list):
+        size = Tensor(size, dtype=mstype.int64)
+    elif isinstance(size, Tensor) and size.ndim == 0 and size.size == 1:
+        size = size.reshape(1)
+    output = zero_op(size, value)
     return output
 
 
@@ -1012,8 +1050,8 @@ def zeros_like(input, *, dtype=None):
         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.
+        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.
@@ -1025,6 +1063,9 @@ def zeros_like(input, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.arange(4).reshape(2, 2))
         >>> output = ops.zeros_like(x, dtype=mindspore.float32)
         >>> print(output)
@@ -1032,9 +1073,10 @@ def zeros_like(input, *, dtype=None):
          [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)
+    _zeros_like = _get_cache_prim(P.ZerosLike)()
+    _cast = _get_cache_prim(P.Cast)()
+    output = _zeros_like(input)
+    output = _cast(output, _dtype)
     return output
 
 
@@ -1052,6 +1094,7 @@ def tile(input, multiples):
     Args:
         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`.
@@ -1062,7 +1105,7 @@ def tile(input, multiples):
         the dimension of `input` is `input.dim`, and the shape of `input` is :math:`(x_1, x_2, ..., x_S)`.
 
         - If `input.dim = d`, then the shape of their corresponding positions can be multiplied, and
-          the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_R)`.
+          the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_S)`.
         - If `input.dim < d`, fill in multiple 1 in the length of the shape of `input` until their
           lengths are consistent. Such as set the shape of `input` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
           then the shape of their corresponding positions can be multiplied, and the shape of Outputs is
@@ -1071,22 +1114,25 @@ def tile(input, multiples):
     Raises:
         TypeError: If `multiples` is not a tuple or its elements are not all int.
         ValueError: If the elements of `multiples` are not all greater than 0.
-        ValueError: If the length of `multiples` are smaller than the length of dimension in `input_x`.
+        ValueError: If the length of `multiples` are smaller than the length of dimension in `input`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
         >>> multiples = (2, 3)
-        >>> output = ops.tile(input_x, multiples)
+        >>> output = ops.tile(input, multiples)
         >>> print(output)
         [[1.  2.  1.  2.  1.  2.]
          [3.  4.  3.  4.  3.  4.]
          [1.  2.  1.  2.  1.  2.]
          [3.  4.  3.  4.  3.  4.]]
         >>> multiples = (2, 3, 2)
-        >>> output = ops.tile(input_x, multiples)
+        >>> output = ops.tile(input, multiples)
         >>> print(output)
         [[[1. 2. 1. 2.]
           [3. 4. 3. 4.]
@@ -1101,7 +1147,8 @@ def tile(input, multiples):
           [1. 2. 1. 2.]
           [3. 4. 3. 4.]]]
     """
-    return tile_(input, multiples)
+    tile_op = _get_cache_prim(P.Tile)()
+    return tile_op(input, multiples)
 
 
 def range(start, end, step):
@@ -1135,6 +1182,8 @@ def range(start, end, step):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> start = Tensor(0, mstype.int32)
         >>> end = Tensor(10, mstype.int32)
         >>> step = Tensor(4, mstype.int32)
@@ -1159,7 +1208,7 @@ def unique(input):
     The shape of Tensor `y` and Tensor `idx` is different in most cases, because Tensor `y` will be deduplicated,
     and the shape of Tensor `idx` is consistent with the input.
 
-    To get the same shape between `idx` and `y`, please ref to :class:'mindspore.ops.UniqueWithPad' operator.
+    To get the same shape between `idx` and `y`, please ref to :class:`mindspore.ops.UniqueWithPad` operator.
 
     Args:
         input (Tensor): The input tensor.
@@ -1262,10 +1311,10 @@ def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
     Args:
         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.
+            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
@@ -1287,6 +1336,9 @@ def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> 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)
@@ -1321,15 +1373,16 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
         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.
+        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 `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`.
+        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
@@ -1339,6 +1392,9 @@ def searchsorted(sorted_sequence, values, *, out_int32=False, right=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> 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)
@@ -1379,6 +1435,8 @@ def ger(input, vec2):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor([1., 2., 3., 4.], mindspore.float32)
         >>> vec2 = Tensor([1., 2., 3.], mindspore.float32)
         >>> output = ops.ger(input, vec2)
@@ -1398,7 +1456,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/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -1411,6 +1469,9 @@ def size(input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> output = ops.size(input_x)
         >>> print(output)
@@ -1437,6 +1498,9 @@ def shape(input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> output = ops.shape(input_x)
         >>> print(output)
@@ -1462,6 +1526,9 @@ def dyn_shape(input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> output = ops.dyn_shape(input_x)
         >>> print(output)
@@ -1490,6 +1557,9 @@ def rank(input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> output = ops.rank(input_tensor)
         >>> print(output)
@@ -1504,7 +1574,7 @@ def reshape(input, shape):
     """
     Rearranges the input Tensor based on the given shape.
 
-    The 'shape' can only have one -1 at most, in which case it’s inferred from the remaining dimensions and
+    The '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:
@@ -1524,6 +1594,9 @@ def reshape(input, shape):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> output = ops.reshape(input, (3, 2))
         >>> print(output)
@@ -1535,26 +1608,34 @@ def reshape(input, shape):
 
 
 def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
-    """
+    r"""
     Reverses variable length slices.
 
     Args:
         x (Tensor): The input to reverse, supporting all number types including bool.
         seq_lengths (Tensor): Specified reversing length, must be a 1-D vector with int32 or int64 types.
         seq_dim (int): The dimension where reversal is performed. Required.
-        batch_dim (int): The input is sliced in this dimension. Default: 0.
+        batch_dim (int): The input is sliced in this dimension. Default: ``0`` .
 
     Returns:
         Tensor, with the same shape and data type as `x`.
 
     Raises:
         TypeError: If `seq_dim` or `batch_dim` is not an int.
-        ValueError: If value of `batch_dim` is equal to or greater than length of shape of input.
+        ValueError: If :math:`len(seq\_lengths) != x.shape[batch\_dim]`.
+        ValueError: If :math:`batch\_dim == seq\_dim`.
+        ValueError: If :math:`seq\_dim < 0` or :math:`seq\_dim >= len(x.shape)`.
+        ValueError: If :math:`batch\_dim < 0` or :math:`batch\_dim >= len(x.shape)`.
+        RuntimeError: If any value of `seq_lengths` is less than 0.
+        RuntimeError: If any value of `seq_lengths` is larger than `x.shape[seq_dim]`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> seq_lengths = Tensor(np.array([1, 2, 3]))
         >>> output = ops.reverse_sequence(x, seq_lengths, seq_dim=1)
@@ -1599,12 +1680,13 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
 
     Args:
         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'.
+        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.
+        start_dim (int, optional): The first dimension to flatten. Default: ``1`` .
+        end_dim (int, optional): The last dimension to flatten. Default: ``-1`` .
 
     Returns:
         Tensor. If no dimensions are flattened, returns the original `input`, otherwise return the flattened Tensor.
@@ -1622,26 +1704,38 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
         >>> output = ops.flatten(input_x)
         >>> print(output.shape)
         (1, 24)
     """
+
+    def check_axis_valid(axis, ndim):
+        if axis < -ndim or axis >= ndim:
+            raise ValueError("'start_dim' or 'end_dim' out of range.")
+
+    def check_dim_valid(start_dim, end_dim):
+        if start_dim > end_dim:
+            raise ValueError("For 'flatten', 'start_dim' cannot come after 'end_dim'.")
+
     def canonicalize_axis(axis, x_rank):
         ndim = x_rank if x_rank != 0 else 1
-        if axis < -ndim or axis >= ndim:
-            const_utils.raise_value_error("'start_dim' or 'end_dim' out of range.")
+        check_axis_valid(axis, ndim)
         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):
+    if not isinstance(start_dim, int) or not isinstance(end_dim, int) or \
+            isinstance(start_dim, bool) or isinstance(end_dim, bool):
         raise TypeError(f"For 'flatten', both 'start_dim' and 'end_dim' must be int.")
     check_flatten_order_const(order)
     if order == 'F':
-        perm = F.make_range(0, F.rank(input))
-        new_order = F.tuple_reversed(perm)
+        perm = ops.make_range(0, ops.rank(input))
+        new_order = ops.tuple_reversed(perm)
         input = _get_cache_prim(P.Transpose)()(input, new_order)
 
     # Handle the default case.
@@ -1655,8 +1749,7 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     # 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'.")
+    check_dim_valid(start_dim, 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,))
@@ -1779,6 +1872,8 @@ def select(cond, x, y):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> # 1) Both inputs are Tensor
         >>>
         >>> cond = Tensor([True, False])
@@ -1822,15 +1917,15 @@ def select(cond, x, y):
             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)
+        x_shape = ops.shape(x)
+        y_shape = ops.shape(y)
+        cond_shape = ops.shape(cond)
+        all_constant = ops.isconstant(cond_shape) and ops.isconstant(x_shape) and ops.isconstant(y_shape)
         if all_constant and not _check_select_shape_same(cond_shape, x_shape, y_shape):
             broadcast_shape = _calc_broadcast_shape(cond_shape, x_shape, y_shape)
-            new_cond = F.broadcast_to(cond, broadcast_shape)
-            new_x = F.broadcast_to(x, broadcast_shape)
-            new_y = F.broadcast_to(y, broadcast_shape)
+            new_cond = ops.broadcast_to(cond, broadcast_shape)
+            new_x = ops.broadcast_to(x, broadcast_shape)
+            new_y = ops.broadcast_to(y, broadcast_shape)
             return tensor_select_(new_cond, new_x, new_y)
 
     return tensor_select_(cond, input_x, input_y)
@@ -1852,7 +1947,7 @@ 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.
 
-    .. warning::
+    Note:
         - `begin` , `end` and `strides` must have the same shape.
         - `begin` , `end` and `strides` are all 1-D Tensor,  and their shape size
           must not greater than the dim of `input_x`.
@@ -1921,17 +2016,15 @@ def strided_slice(input_x,
     Args:
         input_x (Tensor): The input Tensor to be extracted from.
         begin (tuple[int]): A tuple which represents the location where to start.
-            Only non-negative int is allowed.
         end (tuple[int]): A tuple or which represents the maximum location where to end.
-            Only non-negative int is allowed.
         strides (tuple[int]): A tuple which represents the strides is continuously added
             before reaching the maximum location. Only int is allowed, it can be negative
             which results in reversed slicing.
-        begin_mask (int, optional): Starting index of the slice. Default: 0.
-        end_mask (int, optional): Ending index of the slice. Default: 0.
-        ellipsis_mask (int, optional): An int mask, ignore slicing operation when set to 1. Default: 0.
-        new_axis_mask (int, optional): An int mask for adding new dims. Default: 0.
-        shrink_axis_mask (int, optional): An int mask for shrinking dims. Default: 0.
+        begin_mask (int, optional): Starting index of the slice. Default: ``0`` .
+        end_mask (int, optional): Ending index of the slice. Default: ``0`` .
+        ellipsis_mask (int, optional): An int mask, ignore slicing operation when set to 1. Default: ``0`` .
+        new_axis_mask (int, optional): An int mask for adding new dims. Default: ``0`` .
+        shrink_axis_mask (int, optional): An int mask for shrinking dims. Default: ``0`` .
 
     Returns:
         Tensor, return the extracts a strided slice of a Tensor based on `begin/end` index and `strides`.
@@ -1948,6 +2041,8 @@ def strided_slice(input_x,
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
         ...                   [[5, 5, 5], [6, 6, 6]]], mindspore.float32)
         >>> output = ops.strided_slice(input_x, (1, 0, 2), (3, 1, 3), (1, 1, 1))
@@ -2061,7 +2156,18 @@ def slice(input_x, begin, size):
 
 
 def concat(tensors, axis=0):
-    """Alias for :func:`mindspore.ops.cat()`"""
+    """
+    Alias for :func:`mindspore.ops.cat()`.
+
+    Tutorial Examples:
+        - `Tensor - Tensor Operation <https://mindspore.cn/tutorials/en/r2.2/beginner/tensor.html#tensor-operation>`_
+        - `FGSM Network Adversarial Attack - Implementing FGSM
+          <https://mindspore.cn/tutorials/application/en/r2.2/cv/fgsm.html#implementing-fgsm>`_
+        - `Vision Transformer Image Classification - Building ViT as a whole
+          <https://mindspore.cn/tutorials/application/en/r2.2/cv/vit.html#building-vit-as-a-whole>`_
+        - `Sentiment Classification Implemented by RNN - Dense
+          <https://mindspore.cn/tutorials/application/en/r2.2/nlp/sentiment_analysis.html#dense>`_
+    """
     return cat(tensors, axis)
 
 
@@ -2077,15 +2183,14 @@ def stack(tensors, axis=0):
 
     Args:
         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).
+        axis (int): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
 
     Returns:
         Tensor. A stacked Tensor with the same type as `tensors`.
 
     Raises:
         TypeError: If the data types of elements in `tensors` are not the same.
-        ValueError: If the length of `tensors` is not greater than 0;
+        ValueError: If the length of `tensors` is not greater than zero;
                     or if axis is out of the range [-(R+1), R+1);
                     or if the shapes of elements in tensors are not the same.
 
@@ -2093,6 +2198,8 @@ def stack(tensors, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x1 = Tensor(np.array([0, 1]).astype(np.float32))
         >>> input_x2 = Tensor(np.array([2, 3]).astype(np.float32))
         >>> output = ops.stack((input_x1, input_x2), 0)
@@ -2106,23 +2213,19 @@ def stack(tensors, axis=0):
 
 def unstack(input_x, axis=0):
     r"""
-    Unstacks tensor in specified axis.
-
-    Unstacks a tensor of rank `R` along axis dimension, 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)`.
-
-    This is the opposite of pack.
+    Unstacks tensor in specified axis, this is the opposite of :func:`mindspore.ops.stack`.
+    Assuming input is a tensor of rank `R`, output tensors will have rank `(R-1)`.
 
     Args:
         input_x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`.
             A tensor to be unstacked and the rank of the tensor must be greater than 0.
-        axis (int): Dimension along which to unpack. Default: 0.
+        axis (int): Dimension along which to unpack. Default: ``0`` .
             Negative values wrap around. The range is [-R, R).
 
     Returns:
         A tuple of tensors, the shape of each objects is the same.
+        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)`.
 
     Raises:
         ValueError: If axis is out of the range [-len(input_x.shape), len(input_x.shape)).
@@ -2131,6 +2234,8 @@ def unstack(input_x, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]))
         >>> output = ops.unstack(input_x, 0)
         >>> print(output)
@@ -2152,7 +2257,7 @@ def unbind(input, dim=0):
     Args:
         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.
+        dim (int): Dimension along which to unpack. Negative values wrap around. The range is [-R, R). Default: ``0`` .
 
     Returns:
         A tuple of tensors, the shape of each objects is the same.
@@ -2164,6 +2269,8 @@ def unbind(input, dim=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
         >>> output = ops.unbind(x, dim=0)
         >>> print(output)
@@ -2176,7 +2283,8 @@ def unbind(input, dim=0):
 
 def expand_dims(input_x, axis):
     """
-    Adds an additional dimension to `input_x` at the given axis.
+    Adds an additional dimension to `input_x` at the given axis, the dimension
+    of `input_x` should be greater than or equal to 1.
 
     Note:
         If the specified axis is a negative number, the index is counted
@@ -2200,6 +2308,9 @@ def expand_dims(input_x, axis):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> output = ops.expand_dims(input_tensor, 0)
         >>> print(output)
@@ -2231,6 +2342,9 @@ def unsqueeze(input, dim):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> output = ops.unsqueeze(input_tensor, dim=0)
         >>> print(output)
@@ -2248,33 +2362,37 @@ def squeeze(input, axis=None):
     If `axis` is specified, it will remove the dimensions of size 1 in the given `axis`.
     For example, if the dimension is not specified :math:`axis=None`, input shape is (A, 1, B, C, 1, D),
     then the shape of the output Tensor is (A, B, C, D). If the dimension is specified, the squeeze operation
-    is only performed in the specified dimension. If input shape is (A, 1, B), input Tensor will not be
-    changed when :math:`axis=0` , but when :math:`axis=1` , the shape of the input Tensor will be changed to (A, B).
+    is only performed in the specified dimension. If input shape is (A, 1, B), input Tensor will be changed
+    to (A, B) when :math:`axis=1`, but when :math:`axis=0` or :math:`axis=2`, an error will occur.
 
     Note:
+        - Squeezing a dimension that is not 1 will raise an error.
         - Please note that in dynamic graph mode, the output Tensor will share data with the input Tensor,
           and there is no Tensor data copy process.
         - The dimension index starts at 0 and must be in the range `[-input.ndim, input.ndim]`.
 
     Args:
         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: None, an empty tuple will be used.
+        axis (Union[int, tuple(int), list(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: ``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` 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.
+        TypeError: If `axis` is not an int, tuple or list.
+        TypeError: If `axis` is a tuple or list whose elements are not all int.
         ValueError: If the corresponding dimension of the specified axis isn't equal to 1.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
         >>> output = ops.squeeze(input)
         >>> print(output)
@@ -2284,6 +2402,8 @@ def squeeze(input, axis=None):
     """
     if axis is None:
         axis = ()
+    if isinstance(axis, list):
+        axis = tuple(axis)
     squeeze_ = _get_cache_prim(P.Squeeze)(axis)
     return squeeze_(input)
 
@@ -2322,6 +2442,9 @@ def transpose(input, input_perm):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
         >>> input_perm = (0, 2, 1)
         >>> output = ops.transpose(input, input_perm)
@@ -2354,7 +2477,7 @@ def scatter_mul(input_x, indices, updates):
 
     Args:
         input_x (Parameter): The target tensor to be updated, 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 mul operation whose data type must be int32 or int64.
         updates (Tensor): The tensor doing the mul operation with `input_x`,
             the data type is same as `input_x`, the shape is `indices.shape + input_x.shape[1:]`.
@@ -2363,7 +2486,6 @@ def scatter_mul(input_x, indices, updates):
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
 
     Raises:
-        TypeError: If `use_locking` is not a bool.
         TypeError: If `indices` is not an int32 or int64.
         ValueError: If the shape of `updates` is not equal to `indices.shape + input_x.shape[1:]`.
         RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
@@ -2373,6 +2495,9 @@ def scatter_mul(input_x, indices, updates):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mindspore.float32)
@@ -2442,7 +2567,7 @@ def scatter_max(input_x, indices, updates):
     .. math::
 
         \text{input_x}[\text{indices}[i, ..., j], :]
-        = max(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[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
@@ -2451,6 +2576,7 @@ def scatter_max(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 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:]`.
@@ -2470,6 +2596,9 @@ def scatter_max(input_x, indices, updates):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32), name="input_x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> updates = Tensor(np.ones([2, 2, 3]) * 88, mindspore.float32)
@@ -2488,7 +2617,6 @@ 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.
         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:]`.
@@ -2532,7 +2660,7 @@ def scatter_min(input_x, indices, updates):
     .. math::
 
         \text{input_x}[\text{indices}[i, ..., j], :]
-        = min(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
+        = \min(\text{input_x}[\text{indices}[i, ..., j], :], \text{updates}[i, ..., j, :])
 
     Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent.
     If they have different data types, the lower priority data type will be converted to
@@ -2599,7 +2727,7 @@ def scatter_div(input_x, indices, updates):
           the shape is `indices.shape + input_x.shape[1:]`.
 
     Returns:
-        Tensor, the updated `input_x`, has the same type and shape as `input_x`.
+        Tensor, the updated `input_x`, has the same shape and type as `input_x`.
 
     Raises:
         TypeError: If the type of `indices` is not one of the following dtype: int32, int64.
@@ -2613,6 +2741,9 @@ def scatter_div(input_x, indices, updates):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([[6.0, 6.0, 6.0], [2.0, 2.0, 2.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mindspore.float32)
@@ -2701,6 +2832,9 @@ def scatter_nd(indices, updates, shape):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> indices = Tensor(np.array([[0], [2]]), mindspore.int32)
         >>> updates = Tensor(np.array([[[1, 1, 1, 1], [2, 2, 2, 2],
         ...                             [3, 3, 3, 3], [4, 4, 4, 4]],
@@ -2796,6 +2930,9 @@ def scatter_update(input_x, indices, updates):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> np_x = np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]])
         >>> input_x = mindspore.Parameter(Tensor(np_x, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
@@ -2832,7 +2969,7 @@ def scatter_nd_add(input_x, indices, updates, use_locking=False):
             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`,
             the data type is same as `input_x`, the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
@@ -2849,6 +2986,9 @@ def scatter_nd_add(input_x, indices, updates, use_locking=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -2904,7 +3044,7 @@ def scatter_nd_sub(input_x, indices, updates, use_locking=False):
             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.
             The shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -2921,6 +3061,9 @@ def scatter_nd_sub(input_x, indices, updates, use_locking=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -2976,7 +3119,7 @@ def scatter_nd_mul(input_x, indices, updates, use_locking=False):
             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`.
             The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
@@ -2993,6 +3136,9 @@ def scatter_nd_mul(input_x, indices, updates, use_locking=False):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -3048,7 +3194,7 @@ def scatter_nd_div(input_x, indices, updates, use_locking=False):
             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`.
             The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
@@ -3065,6 +3211,9 @@ def scatter_nd_div(input_x, indices, updates, use_locking=False):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -3121,7 +3270,7 @@ def scatter_nd_max(input_x, indices, updates, use_locking=False):
             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`.
             The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
@@ -3138,6 +3287,9 @@ def scatter_nd_max(input_x, indices, updates, use_locking=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -3189,12 +3341,11 @@ def scatter_nd_min(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 to do the min operation with `input_x`.
             The data type is same as `input_x`, and the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        use_locking (bool): Whether to protect the assignment by a lock. Default: False.
+        use_locking (bool): Whether to protect the assignment by a lock. Default: ``False`` .
 
     Returns:
         Tensor, the updated `input_x`, has the same shape and type as `input_x`.
@@ -3211,6 +3362,9 @@ def scatter_nd_min(input_x, indices, updates, use_locking=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> input_x = Parameter(Tensor(np.ones(8) * 10, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
@@ -3251,9 +3405,10 @@ 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, optional): The dimension to sort along. Default: -1.
+        axis (int, optional): The dimension to sort along. Default: ``-1``, means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
         descending (bool, optional): Controls the sort order. If `descending` is True, the elements
-            are sorted in descending order, or else sorted in ascending order. Default: False.
+            are sorted in descending order, or else sorted in ascending order. Default: ``False`` .
 
     .. warning::
         Currently, the data types of Float16, UInt8, Int8, Int16, Int32, Int64 are well supported.
@@ -3275,6 +3430,9 @@ def sort(input_x, axis=-1, descending=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
         >>> output = ops.sort(x)
         >>> # The output below is based on the Ascend platform.
@@ -3297,9 +3455,10 @@ def argsort(input, axis=-1, descending=False):
 
     Args:
         input(Tensor): The input tensor to sort.
-        axis (int): The axis to sort along. Default: -1, means the last axis
+        axis (int): The axis to sort along. Default: ``-1`` , means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
         descending (bool): The sort order. If `descending` is True then the elements
-            are sorted in descending order by value. Otherwise sort in ascending order. Default: False.
+            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.
@@ -3308,6 +3467,9 @@ def argsort(input, axis=-1, descending=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
         >>> sort = ops.argsort(x)
         >>> print(sort)
@@ -3331,34 +3493,42 @@ def gather(input_params, input_indices, axis, batch_dims=0):
     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])`.
+           On CPU and GPU, an error is raised if an out of bound indice is found. On Ascend, the results may be
+           undefined.
 
         2. The data type of input_params cannot be
-           `bool_ <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore.html#mindspore.dtype>`_ on Ascend
+           `bool_ <https://www.mindspore.cn/docs/en/r2.2/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. It must be greater than or equal to `batch_dims`.
+        axis (Union(int, Tensor[int])): Specifies the dimension index to gather indices.
+                                        It must be greater than or equal to `batch_dims`.
+                                        When `axis` is a Tensor, the size must be 1.
         batch_dims (int): Specifies the number of batch dimensions. It must be less than or euqal to the rank
-                          of `input_indices`. Default: 0.
+                          of `input_indices`. Default: ``0`` .
 
     Returns:
         Tensor, the shape of tensor is
         :math:`input\_params.shape[:axis] + input\_indices.shape[batch\_dims:] + input\_params.shape[axis + 1:]`.
 
     Raises:
-        TypeError: If `axis` is not an int.
-        TypeError: If `input_params` is not a tensor.
-        TypeError: If `input_indices` is not a tensor of type int.
+        TypeError:  If `axis` is not an int or Tensor.
+        ValueError: If `axis` is a Tensor and its size is not 1.
+        TypeError:  If `input_params` is not a tensor.
+        TypeError:  If `input_indices` is not a tensor of type int.
+        RuntimeError: If `input_indices` is out of range `[0, input_param.shape[axis])` on CPU or GPU.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case1: input_indices is a Tensor with shape (5, ).
         >>> input_params = Tensor(np.array([1, 2, 3, 4, 5, 6, 7]), mindspore.float32)
         >>> input_indices = Tensor(np.array([0, 2, 4, 2, 6]), mindspore.int32)
@@ -3407,6 +3577,9 @@ def gather_d(x, dim, index):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)
         >>> index = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int32)
         >>> dim = 1
@@ -3502,6 +3675,9 @@ def gather_nd(input_x, indices):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> output = ops.gather_nd(input_x, indices)
@@ -3512,7 +3688,7 @@ def gather_nd(input_x, indices):
 
 
 def tensor_scatter_add(input_x, indices, updates):
-    """
+    r"""
     Creates a new tensor by adding the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When multiple values are given for the same
     index, the updated result will be the sum of all values. This operation is almost
@@ -3523,18 +3699,23 @@ def tensor_scatter_add(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of `input_x[indices]`. For more details, see use cases.
 
+    .. math::
+        output\left [indices  \right ] = input\_x + update
+
     Note:
-        On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
-        the corresponding `updates` will not be updated to self tensor. On CPU, if some values of
-        the `indices` are out of bound, raising an index error. On Ascend, out of bound checking is
-        not supported, if some values of the `indices` are out of bound, unknown errors may be caused.
+        - On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
+          the corresponding `updates` will not be updated to self tensor.
+        - On CPU, if some values of the `indices` are out of bound, raising an index error.
+        - On Ascend, out of bound checking is not supported, if some values of the `indices` are out of bound,
+          unknown errors may be caused.
 
     Args:
-        input_x (Tensor): The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        input_x (Tensor): The input tensor. The dimension of input_x must be no less than indices.shape[-1].
         indices (Tensor): The index of input tensor whose data type is int32 or int64.
             The rank must be at least 2.
         updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates. Shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+            and updates. And the shape should be
+            equal to :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -3542,7 +3723,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`.
+        RuntimeError: If a value of `indices` is not in `input_x` on CPU backend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3565,7 +3746,7 @@ def tensor_scatter_add(input_x, indices, updates):
 
 
 def tensor_scatter_sub(input_x, indices, updates):
-    """
+    r"""
     Creates a new tensor by subtracting the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When multiple values are provided for the same
     index, the result of the update will be to subtract these values respectively. This operation is almost
@@ -3576,6 +3757,9 @@ def tensor_scatter_sub(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of `input_x[indices]`. For more details, see use cases.
 
+    .. math::
+        output[indices] = input\_x - update
+
     Note:
         On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
         the corresponding `updates` will not be updated to self tensor. On CPU, if some values of
@@ -3583,11 +3767,11 @@ def tensor_scatter_sub(input_x, indices, updates):
         not supported, if some values of the `indices` are out of bound, unknown errors may be caused.
 
     Args:
-        input_x (Tensor): The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        input_x (Tensor): The input tensor. The dimension of input_x must be no less than indices.shape[-1].
         indices (Tensor): The index of input tensor whose data type is int32 or int64.
             The rank must be at least 2.
-        updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+        updates (Tensor): The tensor to update the input tensor, has the same type as `input_x`,
+            and the shape of `updates` should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -3618,7 +3802,7 @@ def tensor_scatter_sub(input_x, indices, updates):
 
 
 def tensor_scatter_max(input_x, indices, updates):
-    """
+    r"""
     By comparing the value at the position indicated by `indices` in `input_x` with the value in the `updates`,
     the value at the index will eventually be equal to the largest one to create a new tensor.
 
@@ -3626,16 +3810,22 @@ def tensor_scatter_max(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of input_x[indices].
 
+    .. math::
+        output\left [indices  \right ] = \max(input\_x, update)
+
     Note:
-        If some values of the `indices` are out of bound, instead of raising an index error,
-        the corresponding `updates` will not be updated to `input_x`.
+        - On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
+          the corresponding `updates` will not be updated to self tensor.
+        - On CPU, if some values of the `indices` are out of bound, raising an index error.
+        - On Ascend, out of bound checking is not supported, if some values of the `indices` are out of bound,
+          unknown errors may be caused.
 
     Args:
-        input_x (Tensor): The target tensor. The dimension of input_x must be no less than indices.shape[-1].
-        indices (Tensor): The index of input tensor whose data type is int32 or int64.
+        input_x (Tensor): The input tensor. The dimension of `input_x` must be no less than indices.shape[-1].
+        indices (Tensor): The index of input tensor whose data type must be int32 or int64.
             The rank must be at least 2.
-        updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+        updates (Tensor): The tensor to update the `input_x` tensor, has the same type as input,
+            and updates.shape should be equal to :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -3643,12 +3833,15 @@ 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`.
+        RuntimeError: If a value of `indices` is not in `input_x` on CPU backend.
 
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -3670,7 +3863,7 @@ def tensor_scatter_max(input_x, indices, updates):
 
 
 def tensor_scatter_min(input_x, indices, updates):
-    """
+    r"""
     By comparing the value at the position indicated by `indices` in `input_x` with the value in the `updates`,
     the value at the index will eventually be equal to the smallest one to create a new tensor.
 
@@ -3678,16 +3871,23 @@ def tensor_scatter_min(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of `input_x[indices]`. For more details, see case below.
 
+    .. math::
+        output\left [indices  \right ] = \min(input\_x, update)
+
     Note:
-        If some values of the `indices` are out of range, instead of raising an index error,
-        the corresponding `updates` will not be hw to `input_x`.
+        - On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
+          the corresponding `updates` will not be updated to self tensor.
+        - On CPU, if some values of the `indices` are out of bound, raising an index error.
+        - On Ascend, out of bound checking is not supported, if some values of the `indices` are out of bound,
+          unknown errors may be caused.
 
     Args:
-        input_x (Tensor): The input tensor. The dimension of input_x must be no less than indices.shape[-1].
+        input_x (Tensor): The input tensor. The dimension of `input_x` must be no less than indices.shape[-1].
         indices (Tensor): The index of input tensor whose data type is int32 or int64.
             The rank must be at least 2.
-        updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+        updates (Tensor): The tensor to update the input tensor, has the same type as `input_x`
+            And the shape of `updates` should be
+            equal to :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -3695,7 +3895,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`.
+        RuntimeError: If a value of `indices` is not in `input_x` on CPU backend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3718,13 +3918,11 @@ def tensor_scatter_min(input_x, indices, updates):
 
 def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none"):
     """
-    Updates the value of the input tensor through the reduction operation.
+    Write all elements in `updates` to the index specified by `indices` in `input_x` according to the reduction
+    operation specified by `reduction`.
+    `axis` controls the direction of the scatter operation.
 
-    tensor_scatter_elements takes three inputs data, updates, and indices of the same rank r >= 1,
-    an optional attribute axis that identifies an axis of data (default is 0),  and another optional attribute reduction
-    that identifies reduction operation. When reduction is set to "none", the update value will be assigned to the
-    output value according to the indices. When reduction is set to "add", the update value will be added to the output
-    value according to the indices.
+    `tensor_scatter_elements` takes three inputs `input_x`, `updates` and `indices` of the same rank r >= 1.
 
     For a 3-D tensor, the output is:
 
@@ -3743,18 +3941,23 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         - On Ascend, the reduction only support set to "none" for now.
         - On Ascend, the data type of `input_x` must be float16 or float32.
 
-    .. note::
-        If some values of the `indices` are out of bound, instead of raising an index error,
-        the corresponding `updates` will not be updated to `input_x`.
+    Note:
+        If some values of the `indices` exceed the upper or lower bounds of the index of `input_x`, instead of raising
+        an index error, the corresponding `updates` will not be updated to `input_x`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        input_x (Tensor): The target tensor. The rank 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,
-          and update.shape should be equal to indices.shape.
-        axis (int): Which axis to scatter, default is 0. Accepted range is [-r, r) where r = rank(input_x).
-        reduction (str): Which reduction operation to scatter, default is "none". Other option: "add".
+        input_x (Tensor): The target tensor. The rank must be at least 1.
+        indices (Tensor): The index of `input_x` to do scatter operation whose data type must be mindspore.int32 or
+            mindspore.int64. Same rank as  `input_x`. And accepted range is [-s, s) where s is the size along axis.
+        updates (Tensor): The tensor doing the scatter operation with `input_x`, has the same type as `input_x` and
+            the same shape as `indices`.
+        axis (int): Which axis to scatter. Accepted range is [-r, r) where r = rank(input_x). Default: ``0``.
+        reduction (str): Which reduction operation to scatter, supports ``"none"`` , ``"add"`` . Default: ``"none"``.
+            When `reduction` is set to ``"none"``, `updates` will be assigned to `input_x` according to  `indices`.
+            When `reduction` is set to ``"add"``, `updates` will be added to `input_x` according to  `indices`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -3771,14 +3974,28 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Parameter(Tensor(np.array([[1, 2, 3, 4, 5]]), mindspore.float32), name="x")
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import Parameter
+        >>> import numpy as np
+        >>> input_x = Parameter(Tensor(np.array([[1, 2, 3, 4, 5]]), mindspore.int32), name="x")
         >>> indices = Tensor(np.array([[2, 4]]), mindspore.int32)
-        >>> updates = Tensor(np.array([[8, 8]]), mindspore.float32)
+        >>> updates = Tensor(np.array([[8, 8]]), mindspore.int32)
         >>> axis = 1
         >>> reduction = "none"
         >>> output = ops.tensor_scatter_elements(input_x, indices, updates, axis, reduction)
         >>> print(output)
-        [[ 1  2  8  4  8]]
+        [[1 2 8 4 8]]
+        >>> input_x = Parameter(Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.int32), name="x")
+        >>> indices = Tensor(np.array([[1, -1, 2], [0, 2, 1]]), mindspore.int32)
+        >>> updates = Tensor(np.array([[1, 2, 2], [4, 5, 8]]), mindspore.int32)
+        >>> axis = 0
+        >>> reduction = "add"
+        >>> output = ops.tensor_scatter_elements(input_x, indices, updates, axis, reduction)
+        >>> print(output)
+        [[ 5  2  3]
+         [ 5  5 14]
+         [ 7 15 11]]
     """
     _tensor_scatter_elements = _get_cache_prim(TensorScatterElements)(axis, reduction)
     return _tensor_scatter_elements(input_x, indices, updates)
@@ -3812,6 +4029,9 @@ def scatter(input, axis, index, src):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[1, 2, 3, 4, 5]]), dtype=ms.float32)
         >>> src = Tensor(np.array([[8, 8]]), dtype=ms.float32)
         >>> index = Tensor(np.array([[2, 4]]), dtype=ms.int64)
@@ -3839,7 +4059,123 @@ def scatter(input, axis, index, src):
         [0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]]
     """
-    return F.tensor_scatter_elements(input_x=input, indices=index, updates=src, axis=axis)
+    return ops.tensor_scatter_elements(input_x=input, indices=index, updates=src, axis=axis)
+
+
+def _get_slice_scatter_const(x_shape, axis, start, end, step):
+    r"""
+    Calculate the rank of input, embedded dimensions and index.
+    """
+    x_rank = len(x_shape)
+    axis = axis if axis >= 0 else axis + x_rank
+    start = start if start is not None else 0
+    start = start if start >= 0 else start + x_rank
+    end = end if end is not None else x_shape[axis]
+    end = end if end >= 0 else end + x_rank
+    end = end if end < x_shape[axis] else x_shape[axis]
+    index = list(builtins.range(start, end, step))
+    return x_rank, index, axis
+
+
+def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
+    r"""
+    Slice the input Tensor in the specified dimension and overlay the slice results with the source Tensor.
+    The `input` is sliced along the specified dimension. The start position of the slice is `start` ,
+    the end position is `end` , and the step size is `step` .
+    Then the slicing result is overwritten with `src` to get the output Tensor.
+
+    Args:
+        input (Tensor): The target Tensor.
+        src (Tensor): The source Tensor.
+        axis (int, optional): The dimension of `input` to be sliced. Default: ``0`` .
+        start (int, optional): The start index to slice in the specified dimension.
+            Default: ``None``, `start` is ``0`` .
+        end (int, optional): The end index to slice in the specified dimension.
+            Default: ``None``, `end` is the length of `input` in the specified dimension.
+        step (int, optional): Step size. Default: ``1``, the distance from the next slice element is ``1`` .
+
+    Returns:
+        Tensor after embedding, has the same shape and type as `input` .
+
+    Raises:
+        ValueError: The shape of `src` is not the same as the shape of `input` slice.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `src` is not a Tensor.
+        TypeError: If `axis` or `step` is not an integer.
+        TypeError: If `start` or `end` is not ``None`` or an integer.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> a = ms.ops.zeros((4, 6))
+        >>> b = ms.ops.ones((4, 3))
+        >>> output = ms.ops.slice_scatter(a, b, axis=1, start=0, end=5, step=2)
+        >>> print(output)
+        [[1. 0. 1. 0. 1. 0.]
+         [1. 0. 1. 0. 1. 0.]
+         [1. 0. 1. 0. 1. 0.]
+         [1. 0. 1. 0. 1. 0.]]
+    """
+    input_shape = input.shape
+    input_rank, index, axis = _get_slice_scatter_const(input_shape, axis, start, end, step)
+
+    src_shape = src.shape
+    index_shape = input_shape[:axis] + (len(index),) + input_shape[axis + 1:]
+    index_tensor = ms.Tensor(index)
+    for _ in builtins.range(axis):
+        index_tensor = index_tensor.expand_dims(0)
+
+    if index_shape != src_shape:
+        raise ValueError(f"For slice_scatter, src shape should be equal to the slice size,"
+                         f"but got src shape {src_shape} and slice shape {index_shape}")
+    for _ in builtins.range(input_rank - axis - 1):
+        index_tensor = index_tensor.expand_dims(-1)
+    index_tensor = index_tensor.broadcast_to(src.shape)
+    return tensor_scatter_elements(input, axis=axis, indices=index_tensor, updates=src)
+
+
+def select_scatter(input, src, axis, index):
+    r"""
+    On the specified dimension `axis` of `input` , `src` is scattered into `input` on the specified `index` of `input` .
+
+    Args:
+        input (Tensor): The target Tensor.
+        src (Tensor): The source Tensor.
+        axis (int): The dimension of `input` to be embedded.
+        index (int): The location of scattering on the specified dimension.
+
+    Returns:
+        Tensor after embedding, has the same shape and type as `input` .
+
+    Raises:
+        ValueError: The shape of `src` is not the same as the shape scattered over `input` .
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `src` is not a Tensor.
+        TypeError: If `axis` or `index` is not an integer.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> a = ms.ops.zeros((2, 3, 3))
+        >>> b = ms.ops.ones((2, 3))
+        >>> output = ms.ops.select_scatter(a, b, axis=1, index=1)
+        >>> print(output)
+        [[[0. 0. 0.]
+          [1. 1. 1.]
+          [0. 0. 0.]]
+         [[0. 0. 0.]
+          [1. 1. 1.]
+          [0. 0. 0.]]]
+    """
+    src = src.expand_dims(axis=axis)
+    x_rank = input.ndim
+    axis = axis if axis >= 0 else axis + x_rank
+    index = index if index >= 0 else index + x_rank
+    return slice_scatter(input, src, axis, start=index, end=index + 1)
 
 
 def space_to_batch_nd(input_x, block_size, paddings):
@@ -3888,6 +4224,8 @@ def space_to_batch_nd(input_x, block_size, paddings):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> block_size = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
         >>> input_x = Tensor(np.array([[[[1, 2], [3, 4]]]]), mindspore.float32)
@@ -3915,10 +4253,10 @@ def batch_to_space_nd(input_x, block_shape, crops):
     :math:`(n', c_1, ... c_k, w'_1, ..., w'_M)`, where
 
     .. 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}
+        \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),
@@ -3949,6 +4287,9 @@ def batch_to_space_nd(input_x, block_shape, crops):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> block_shape = [2, 2]
         >>> crops = [[0, 0], [0, 0]]
         >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
@@ -3969,7 +4310,7 @@ def nonzero(input):
     Return a Tensor of the positions of all non-zero values.
 
     Args:
-        input (Tensor): The shape of Tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is int, float or bool.
+        input (Tensor): The input Tensor, its rank should be greater than or eaqual to 1.
 
     Returns:
         Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
@@ -4017,23 +4358,23 @@ def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_
             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.
+            and `num_cols`, meaning value of k must be in (-num_rows, num_cols). Default: ``0`` .
         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.
+            :math:`x.shape[-1] - min(k[1], 0)`. Default: ``-1`` .
         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.
+            greater than :math:`x.shape[-1] - min(k[1], 0)`.  Default: ``-1`` .
         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.
+            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".
+            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
@@ -4049,8 +4390,8 @@ def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_
     Returns:
         A Tensor. Has the same type as `x`.
         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)` .
+        :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.
@@ -4102,7 +4443,7 @@ def matrix_diag(x, k=0, num_rows=-1, num_cols=-1, padding_value=0, align="RIGHT_
     return matrix_diag_v3(x, k, num_rows, num_cols, padding_value)
 
 
-def matrix_diag_part(x, k=0, padding_value=0, align="RIGHT_LEFT"):
+def matrix_diag_part(x, k, padding_value, align="RIGHT_LEFT"):
     r"""
     Returns the diagonal part of input tensor.
     Returns a tensor with the k[0]-th to k[1]-th diagonals of `x`. Some diagonals are shorter than
@@ -4110,21 +4451,21 @@ def matrix_diag_part(x, k=0, padding_value=0, align="RIGHT_LEFT"):
 
     Args:
         x (Tensor): The input Tensor with rank r, where r >= 2.
-        k (Union[int, Tensor], optional): A Tensor of type int32. Diagonal offset(s). Positive value means
+        k (Tensor): A Tensor of type int32. 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 value of k has restructions, meaning
             value of k must be in (-x.shape[-2], x.shape[-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 (Tensor): A Tensor with only one value. Have the same dtype as x.
+            The number to fill the area outside the specified diagonal band.
+        align (str, optional): An optional string from: ``"RIGHT_LEFT"`` , ``"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). Default: ``"RIGHT_LEFT"`` . Default: ``"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, ..., 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)`
@@ -4146,6 +4487,9 @@ def matrix_diag_part(x, k=0, padding_value=0, align="RIGHT_LEFT"):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3, 4],
         ...                      [5, 6, 7, 8],
         ...                      [9, 8, 7, 6]]), mindspore.float32)
@@ -4163,7 +4507,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"): # pylint: disable=redefined-outer-name
+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
@@ -4187,10 +4531,10 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"): # pylint: disable=red
             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 :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,
-            respectively. "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals
+            Input k must be const Tensor when taking Graph mode. 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).
 
     Returns:
@@ -4218,6 +4562,9 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"): # pylint: disable=red
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[7, 7, 7, 7],
         ...                      [7, 7, 7, 7],
         ...                      [7, 7, 7, 7]]), mindspore.float32)
@@ -4258,7 +4605,7 @@ def meshgrid(*inputs, indexing='xy'):
             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
-            :math:`(N, M, P)` for 'xy' indexing and :math:`(M, N, P)` for 'ij' indexing. Default: 'xy'.
+            :math:`(N, M, P)` for 'xy' indexing and :math:`(M, N, P)` for 'ij' indexing. Default: ``'xy'`` .
 
     Returns:
         Tensors, a Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
@@ -4334,9 +4681,10 @@ def affine_grid(theta, size, align_corners=False):
             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. Default: False.
+            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. Default: ``False`` .
+
     Returns:
         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.
@@ -4371,7 +4719,7 @@ def affine_grid(theta, size, align_corners=False):
     return affine_grid_op(theta, size)
 
 
-def broadcast_to(input, shape): # pylint: disable=redefined-outer-name
+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)`,
@@ -4414,7 +4762,7 @@ def broadcast_to(input, shape): # pylint: disable=redefined-outer-name
     input shape :math:`(1, 5, 9)`, instead of operating the dim-filling process first, it raises errors directly.
 
     Args:
-        input (Tensor): The input Tensor. Supported types are: float16, float32, int32, int8, uint8, bool.
+        input (Tensor): The input Tensor.
         shape (tuple): The target shape to broadcast. Can be fully specified, or have -1 in one position
                        where it will be substituted by the input tensor's shape in that position, see example.
 
@@ -4430,6 +4778,8 @@ def broadcast_to(input, shape): # pylint: disable=redefined-outer-name
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> shape = (2, 3)
         >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
         >>> output = ops.broadcast_to(x, shape)
@@ -4443,7 +4793,7 @@ def broadcast_to(input, shape): # pylint: disable=redefined-outer-name
         [[1. 1.]
          [2. 2.]]
     """
-    if isinstance(shape, Tensor) or F.is_sequence_value_unknown(shape):
+    if isinstance(shape, Tensor) or ops.is_sequence_value_unknown(shape):
         _dyn_broadcast_to = _get_cache_prim(DynamicBroadcastTo)()
         return _dyn_broadcast_to(input, shape)
     _broadcast_to = _get_cache_prim(P.BroadcastTo)(shape)
@@ -4471,8 +4821,8 @@ def unsorted_segment_min(x, segment_ids, num_segments):
 
     Args:
         x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`. With float16, float32 or int32 data type.
-        segment_ids (Tensor): A `1-D` tensor whose shape is :math:`(x_1)`,
-                              the value must be non-negative tensor. The data type must be int32.
+        segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
+            Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
         num_segments (int): The value specifies the number of distinct `segment_ids`.
 
     Returns:
@@ -4522,8 +4872,8 @@ def unsorted_segment_max(x, segment_ids, num_segments):
 
     Args:
         x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`. With float16, float32 or int32 data type.
-        segment_ids (Tensor): A `1-D` tensor whose shape is :math:`(x_1)`,
-                              the value must be non-negative tensor. The data type must be int32.
+        segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
+            Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
         num_segments (int): The value specifies the number of distinct `segment_ids`.
 
     Returns:
@@ -4730,6 +5080,8 @@ def population_count(input_x):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([0, 1, 3], mindspore.int16)
         >>> output = ops.population_count(input_x)
         >>> print(output)
@@ -4765,6 +5117,43 @@ def is_tensor(obj):
     return isinstance(obj, Tensor)
 
 
+def is_nonzero(input):
+    """
+    Determine whether the input Tensor contains 0 or False. The input can only be a single element.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Bool, returns False if the input Tensor contains a unit element of 0 or a single element of False,
+        otherwise returns True.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        ValueError: If the element number of `input` is not equal to 1.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor([[[False]]])
+        >>> x2 = Tensor([[3.5]])
+        >>> out1 = ops.is_nonzero(x1)
+        >>> print(out1)
+        False
+        >>> out2 = ops.is_nonzero(x2)
+        >>> print(out2)
+        True
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f'For is_nonzero, the input must be a Tensor, but got {type(input)}.')
+    if input.numel() != 1:
+        raise ValueError(f"For is_nonzero, the numel of input must be 1, but got {input.numel()}.")
+    out = ops.squeeze(input)
+    return bool(out)
+
+
 def scalar_cast(input_x, input_y):
     """
     Casts the input scalar to another type.
@@ -4783,6 +5172,8 @@ def scalar_cast(input_x, input_y):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> output = ops.scalar_cast(255.0, mindspore.int32)
         >>> print(output)
         255
@@ -4791,7 +5182,7 @@ def scalar_cast(input_x, input_y):
 
 
 def tensor_scatter_mul(input_x, indices, updates):
-    """
+    r"""
     Creates a new tensor by multiplying the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When divided values are provided for the same
     index, the result of the update will multiply these values respectively. Except that
@@ -4801,15 +5192,19 @@ def tensor_scatter_mul(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of `input_x[indices]`. For more details, see use cases.
 
+    .. math::
+        output[indices] = input\_x \times update
+
     Note:
         - If some values of the `indices` are out of bound, instead of raising an index error,
           the corresponding `updates` will not be updated to `input_x`.
 
     Args:
-        input_x (Tensor): The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        input_x (Tensor): The input tensor. The dimension of `input_x` must be no less than indices.shape[-1].
         indices (Tensor): The index of input tensor whose data type is int32 or int64. The rank must be at least 2.
-        updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+        updates (Tensor): The tensor to update the input tensor, has the same type as `input_x`,
+            and the shape of `updates` should be equal to
+            :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -4817,12 +5212,15 @@ 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`.
+        RuntimeError: If a value of `indices` is not in `input_x` on CPU backend.
 
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [0, 0]]), mindspore.int32)
         >>> updates = Tensor(np.array([1.0, 2.2]), mindspore.float32)
@@ -4844,7 +5242,7 @@ def tensor_scatter_mul(input_x, indices, updates):
 
 
 def tensor_scatter_div(input_x, indices, updates):
-    """
+    r"""
     Creates a new tensor by dividing the values from the positions in `input_x` indicated by
     `indices`, with values from `updates`. When divided values are provided for the same
     index, the result of the update will be to divided these values respectively. Except that
@@ -4854,18 +5252,25 @@ def tensor_scatter_div(input_x, indices, updates):
     there must be a corresponding value in `updates`. The shape of `updates` should be
     equal to the shape of `input_x[indices]`. For more details, see use cases.
 
+    .. math::
+        output\left [indices  \right ] = input\_x \div update
+
     Note:
-        - If some values of the `indices` are out of bound, instead of raising an index error,
-          the corresponding `updates` will not be updated to `input_x`.
+        - On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
+          the corresponding `updates` will not be updated to self tensor.
+        - On CPU, if some values of the `indices` are out of bound, raising an index error.
+        - On Ascend, out of bound checking is not supported, if some values of the `indices` are out of bound,
+          unknown errors may be caused.
         - The operator can't handle division by 0 exceptions, so the user needs to make sure
           there is no 0 value in `updates`.
 
     Args:
-        input_x (Tensor): The target tensor. The dimension of input_x must be no less than indices.shape[-1].
+        input_x (Tensor): The input tensor. The dimension of input_x must be no less than indices.shape[-1].
         indices (Tensor): The index of input tensor whose data type is int32 or int64.
             The rank must be at least 2.
-        updates (Tensor): The tensor to update the input tensor, has the same type as input,
-            and updates.shape should be equal to indices.shape[:-1] + input_x.shape[indices.shape[-1]:].
+        updates (Tensor): The tensor to update the `input_x` tensor, has the same type as `input_x`.
+            And the shape of `updates` should be
+            equal to :math:`indices.shape[:-1] + input\_x.shape[indices.shape[-1]:]`.
 
     Returns:
         Tensor, has the same shape and type as `input_x`.
@@ -4906,8 +5311,7 @@ def scalar_to_tensor(input_x, dtype=mstype.float32):
 
     Args:
         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.
+        dtype (mindspore.dtype): The target data type. Only constant value is allowed. Default: ``mstype.float32``.
 
     Returns:
         Tensor. 0-D Tensor and the content is the input.
@@ -4919,6 +5323,8 @@ def scalar_to_tensor(input_x, dtype=mstype.float32):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> data = 1
         >>> output = ops.scalar_to_tensor(data, mindspore.float32)
         >>> print(output)
@@ -4936,7 +5342,7 @@ def tuple_to_array(input_x):
 
     Args:
         input_x (tuple): A tuple of numbers. These numbers have the same type. Only constant value is allowed.
-            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.
 
     Returns:
         Tensor, if the input tuple contains `N` numbers, then the shape of the output tensor is (N,).
@@ -5024,6 +5430,9 @@ def masked_fill(input_x, mask, value):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
         >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
         >>> output = ops.masked_fill(input_x, mask, 0.5)
@@ -5077,7 +5486,7 @@ def diagflat(input, offset=0):
 
     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.
+        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.
@@ -5094,6 +5503,8 @@ def diagflat(input, offset=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([1, 2], mindspore.float32)
         >>> output = ops.diagflat(x, 1)
         >>> print(output)
@@ -5132,11 +5543,11 @@ def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
         kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
             for height and width. If type is int, it means that height equal with width. Must be specified.
         dilation (Union[int, tuple[int], list[int]]): The size of the dilation, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width.
         padding_value (Union[int, tuple[int], list[int]]): The size of the padding, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            for height and width. If type is int, it means that height equal with width.
         stride (Union[int, tuple[int], list[int]]): The size of the stride, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 0.
+            for height and width. If type is int, it means that height equal with width.
 
     Returns:
         A 4D Tensor, with same type as 'input_x'.
@@ -5154,6 +5565,9 @@ def col2im(input_x, output_size, kernel_size, dilation, padding_value, stride):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor(input_data=np.random.rand(16, 16, 4, 25), dtype=mstype.float32)
         >>> output_size = Tensor(input_data=[8, 8], dtype=mstype.int32)
         >>> output = ops.col2im(x, output_size, [2, 2], [2, 2], [2, 2], [2, 2])
@@ -5172,10 +5586,10 @@ def _split_int(x, split_size_or_sections, axis):
     arr_shape = x.shape
     length_along_dim = arr_shape[axis]
     if split_size_or_sections > length_along_dim:
-        res = P.Split(axis, 1)(x)
+        res = _get_cache_prim(P.Split)(axis, 1)(x)
     elif length_along_dim % split_size_or_sections == 0:
         sections = length_along_dim // split_size_or_sections
-        res = P.Split(axis, sections)(x)
+        res = _get_cache_prim(P.Split)(axis, sections)(x)
     else:
         num_sections = length_along_dim // split_size_or_sections
         length1 = num_sections * split_size_or_sections
@@ -5184,8 +5598,8 @@ def _split_int(x, split_size_or_sections, axis):
         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))
+        res = _get_cache_prim(P.Split)(axis, num_sections)(tensor_slice(x, start1, size1)) + \
+              _get_cache_prim(P.Split)(axis, 1)(tensor_slice(x, start2, size2))
     return res
 
 
@@ -5202,7 +5616,8 @@ def _split_sub_tensors(x, split_size_or_sections, axis):
     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):
+    for i in ms_arrange(len(new_indices)):
+        idx = new_indices[i]
         begin[axis] = 0 if i == 0 else new_indices[i - 1]
         end[axis] = idx
         sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
@@ -5222,7 +5637,7 @@ def split(tensor, split_size_or_sections, axis=0):
             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.
+        axis (int): The axis along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -5239,6 +5654,8 @@ def split(tensor, split_size_or_sections, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import ops, Tensor
         >>> input_x = np.arange(9).astype("float32")
         >>> output = ops.split(Tensor(input_x), 3)
         >>> print(output)
@@ -5276,7 +5693,7 @@ def split(tensor, split_size_or_sections, axis=0):
     return tuple(res)
 
 
-def tril(input, diagonal=0): # pylint: disable=redefined-outer-name
+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.
@@ -5300,6 +5717,8 @@ def tril(input, diagonal=0): # pylint: disable=redefined-outer-name
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[ 1,  2,  3,  4],
         ...                      [ 5,  6,  7,  8],
         ...                      [10, 11, 12, 13],
@@ -5335,13 +5754,16 @@ def tril(input, diagonal=0): # pylint: disable=redefined-outer-name
     return tril_(input)
 
 
-def triu(input, diagonal=0): # pylint: disable=redefined-outer-name
+def triu(input, diagonal=0):  # pylint: disable=redefined-outer-name
     r"""
     Returns the upper triangle part of 'input' (elements that contain the diagonal and below),
     and set the other elements to zeros.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        input (Tensor): The input tensor with shape :math:`(N,∗)` where ∗ means any number of additional dimensions.
+        input (Tensor): The input tensor with shape :math:`(M, N, *)` where * means any number of additional dimensions.
         diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
             indicating the main diagonal.
 
@@ -5351,12 +5773,14 @@ def triu(input, diagonal=0): # pylint: disable=redefined-outer-name
     Raises:
         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.
+        ValueError: If the dimension of `input` is less than 2.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[ 1,  2,  3,  4],
         ...                      [ 5,  6,  7,  8],
         ...                      [10, 11, 12, 13],
@@ -5391,7 +5815,7 @@ def triu(input, diagonal=0): # pylint: disable=redefined-outer-name
     return _get_cache_prim(P.Triu)(diagonal)(input)
 
 
-@constexpr
+@_primexpr
 def _canonicalize_axis(axis, ndim):
     """
     Check axes are within the number of dimensions of tensor x and normalize the negative axes.
@@ -5420,7 +5844,7 @@ def _canonicalize_axis(axis, ndim):
     raise ValueError(f"duplicate axis in {axis}.")
 
 
-@constexpr
+@_primexpr
 def _list_comprehensions(obj, item=None, return_tuple=False):
     """
     Generates a new list or tuple by list comprehension.
@@ -5428,17 +5852,19 @@ def _list_comprehensions(obj, item=None, return_tuple=False):
     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
+        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.
+        return_tuple(bool): If ``true`` , returns tuple, else returns list.
 
     Returns:
         List or tuple.
     """
     lst = obj
     if isinstance(obj, int):
-        lst = np.arange(obj)
+        lst = []
+        for i in ms_arrange(obj):
+            lst.append(i)
     if item is None:
         res = list(lst)
     else:
@@ -5448,7 +5874,7 @@ def _list_comprehensions(obj, item=None, return_tuple=False):
     return res
 
 
-@constexpr
+@_primexpr
 def _tuple_setitem(tup, idx, value):
     """
     Returns a tuple with specified `idx` set to `value`.
@@ -5471,7 +5897,8 @@ def _tensor_split_sub_tensors(x, indices_or_sections, axis):
     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):
+    for i in ms_arrange(len(indices_or_sections)):
+        idx = indices_or_sections[i]
         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)
@@ -5518,18 +5945,17 @@ def tensor_split(input, indices_or_sections, axis=0):
 
             - If `indices_or_sections` is an integer n, input tensor will be split into n sections.
 
-              - If :math:`input.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 :math:`input.shape(axis)` can be divisible by n, sub-sections will have equal size
+                :math:`input.shape(axis) / n` .
+              - If :math:`input.shape(axis)` is not divisible by n, the first :math:`input.shape(axis) % n` sections
+                will have size :math:`input.shape(axis) // n + 1` , and the rest will have
+                size :math:`input.shape(axis) // n` .
             - If `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.
+        axis (int): The axis along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -5545,6 +5971,8 @@ def tensor_split(input, indices_or_sections, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = np.arange(9).astype("float32")
         >>> output = ops.tensor_split(Tensor(input_x), 3)
         >>> print(output)
@@ -5594,6 +6022,8 @@ def vsplit(input, indices_or_sections):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = np.arange(9).reshape((3, 3)).astype('float32')
         >>> output = ops.vsplit(Tensor(input_x), 3)
         >>> print(output)
@@ -5628,6 +6058,8 @@ def hsplit(input, indices_or_sections):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = np.arange(6).reshape((2, 3)).astype('float32')
         >>> output = ops.hsplit(Tensor(input_x), 3)
         >>> print(output)
@@ -5659,6 +6091,8 @@ def dsplit(input, indices_or_sections):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = np.arange(6).reshape((1, 2, 3)).astype('float32')
         >>> output = ops.dsplit(Tensor(input_x), 3)
         >>> print(output)
@@ -5674,13 +6108,16 @@ def dsplit(input, indices_or_sections):
     return tensor_split(input, indices_or_sections, 2)
 
 
-def _init_and_select_elem(input, initial, where, cmp_fn):    # pylint: disable=redefined-outer-name
+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 where is not None and not isinstance(where, Tensor):
+        where = Tensor(where, dtype=mstype.bool_)
+
+    if where is not None and (where.shape or not where):
         if initial is None:
             raise ValueError('initial value must be provided for where masks')
         where = where.broadcast_to(input.shape)
@@ -5689,13 +6126,15 @@ def _init_and_select_elem(input, initial, where, cmp_fn):    # pylint: disable=r
     return input
 
 
-def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pylint: disable=redefined-outer-name
+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.
+        - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
+        - When `axis` is ``None``, `keepdims` and subsequent parameters have no
+          effect. At the same time, the index is fixed to return 0.
 
     .. warning::
         - If there are multiple maximum values, the index of the first maximum value is used.
@@ -5705,16 +6144,18 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
 
     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.
+        axis (int): The dimension to reduce. When `axis` is ``None``, computing the maximum value of all elements
+            in `input` .Default: ``None`` .
         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.
+            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.
+            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 maximum value of the input
@@ -5722,8 +6163,9 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
 
         - 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)` .
+          is true, the shape of output tensors is :math:`(input_1, input_2, ..., input_{axis-1}, 1, input_{axis+1},
+          ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ..., input_{axis-1}, input_{axis+1},
+          ..., input_N)` .
 
     Raises:
         TypeError: If `input` is not Tensor.
@@ -5735,15 +6177,24 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-        >>> output, index,  = ops.max(x, keepdims=True)
+        >>> output, index = ops.max(x)
         >>> print(output, index)
         0.7 0
+        >>> y = Tensor(np.array([[0.0, 0.3, 0.4, 0.5, 0.1],
+        ...                      [3.2, 0.4, 0.1, 2.9, 4.0]]), mindspore.float32)
+        >>> output, index = ops.max(y, axis=0, keepdims=True)
+        >>> print(output, index)
+        [[3.2 0.4 0.4 2.9 4. ]] [[1 1 0 1 1]]
     """
     if not input.shape:
         return (input, Tensor(0, dtype=mstype.int32))
     if axis is None:
-        return (reduce_max(input), Tensor(0, dtype=mstype.int32))
+        reduce_max_op = _get_cache_prim(P.ReduceMax)()
+        return (reduce_max_op(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):
@@ -5760,28 +6211,34 @@ def argmax(input, dim=None, keepdim=False):
 
     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.
+        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.
+            dimension. Ignored if `dim` is None. Default: ``False`` .
 
     Returns:
         Tensor, indices of the maximum values across a dimension.
 
     Raises:
+        TypeError: If `keepdim` is not bool.
         ValueError: If `dim` is out of range.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
         >>> output = ops.argmax(x, dim=-1)
         >>> print(output)
         [1 0 0]
     """
+    _check_attr_dtype("keepdim", keepdim, [bool], "argmax")
     if not input.shape:
         return Tensor(0)
+    if input.dtype == mstype.bool_:
+        input = input.astype(mstype.int32)
     is_dim_none = False
     if dim is None:
         input = reshape_(input, (-1,))
@@ -5793,13 +6250,15 @@ def argmax(input, dim=None, keepdim=False):
     return out
 
 
-def min(input, axis=None, keepdims=False, *, initial=None, where=None):    # pylint: disable=redefined-outer-name
+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.
 
     Note:
-        In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
+        - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
+        - When `axis` is ``None``, `keepdims` and subsequent parameters have no
+          effect. At the same time, the index is fixed to return 0.
 
     .. warning::
         - If there are multiple minimum values, the index of the first minimum value is used.
@@ -5807,16 +6266,17 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
 
     Args:
         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.
+        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.
+            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.
+            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
@@ -5825,8 +6285,9 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
         - **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)` .
+          is true, the shape of output tensors is :math:`(input_1, input_2, ..., input_{axis-1}, 1, input_{axis+1},
+          ..., input_N)` . Otherwise, the shape is :math:`(input_1, input_2, ..., input_{axis-1}, input_{axis+1},
+          ..., input_N)` .
 
     Raises:
         TypeError: If `x` is not Tensor.
@@ -5838,6 +6299,9 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
         >>> output, index = ops.min(x, keepdims=True)
         >>> print(output, index)
@@ -5867,9 +6331,10 @@ def aminmax(input, *, axis=0, keepdims=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.
+            where "rank" is the dimension of `input`. If `axis` is None, computes the minimum and maximum value
+            along the entire input tensor. 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.
+            dimension as the input, or the dimension specified by `axis` is reduced. Default: ``False`` .
 
     Returns:
         tuple (Tensor), containing the minimum value and maximum value of the input tensor.
@@ -5881,13 +6346,16 @@ def aminmax(input, *, axis=0, keepdims=False):
 
     Raises:
         TypeError: If `keepdims` is not a bool.
-        TypeError: If `axis` is not an int.
+        TypeError: If `axis` is not an int and not None.
         ValueError: If `axis` is not in range [-rank, rank).
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
         >>> output0, output1 = ops.aminmax(x)
         >>> print(output0, output1)
@@ -5895,11 +6363,25 @@ def aminmax(input, *, axis=0, keepdims=False):
         >>> output2, output3 = ops.aminmax(x, axis=-1, keepdims=True)
         >>> print(output2, output3)
         [0.] [0.7]
+        >>> x = Tensor(np.array([[0.0, 0.4, 0.6, 0.7, 0.1], [0.78, 0.97, 0.5, 0.82, 0.99]]), mindspore.float32)
+        >>> output4, output5 = ops.aminmax(x, axis=None, keepdims=True)
+        >>> print(output4, output5)
+        [[0.]] [[0.99]]
     """
+    if axis is None:
+        output0, _ = ops.min(input, axis, keepdims)
+        output1, _ = ops.max(input, axis, keepdims)
+        if keepdims is True:
+            output0 = ops.reshape(output0, [1] * input.ndim)
+            output1 = ops.reshape(output1, [1] * input.ndim)
+        return output0, output1
     argmin_with_value_op = P.ArgMinWithValue(axis, keepdims)
     argmax_with_value_op = P.ArgMaxWithValue(axis, keepdims)
     _, output0 = argmin_with_value_op(input)
     _, output1 = argmax_with_value_op(input)
+    if keepdims is True and input.ndim == 0:
+        output0 = ops.reshape(output0, [1])
+        output1 = ops.reshape(output1, [1])
     return output0, output1
 
 
@@ -5940,6 +6422,7 @@ def narrow(input, axis, start, length):
          [ 5 6]
          [ 8 9]]
     """
+    validator.check_value_type("input", input, Tensor, "narrow")
     validator.check_axis_in_range(axis, input.ndim)
     validator.check_int_range(start, 0, input.shape[axis], validator.INC_LEFT)
     validator.check_int_range(length, 1, input.shape[axis] - start, validator.INC_BOTH)
@@ -5974,9 +6457,11 @@ def unsorted_segment_sum(input_x, segment_ids, num_segments):
     is negative, the value will be ignored. 'num_segments' must be equal to the number of different segment_ids.
 
     Args:
-        input_x (Tensor): The shape is :math:`(x_1, x_2, ..., x_R)`.
-        segment_ids (Tensor): Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
-        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments.
+        input_x (Tensor): Input Tensor contains the data to be summed.
+          The shape is :math:`(x_1, x_2, ..., x_R)`.
+        segment_ids (Tensor): TThe label indicates the segment to which each element belongs.
+            Set the shape as :math:`(x_1, x_2, ..., x_N)`, where 0 < N <= R.
+        num_segments (Union[int, Tensor], optional): Set :math:`z` as num_segments, it can be an int or 0-D Tensor.
 
     Returns:
         Tensor, the shape is :math:`(z, x_{N+1}, ..., x_R)`.
@@ -6033,10 +6518,11 @@ def topk(input, k, dim=None, largest=True, sorted=True):
     Args:
         input (Tensor): Input to be computed, data type must be float16, float32 or int32.
         k (int): The number of top or bottom elements to be computed along the last dimension, constant input is needed.
-        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.
+        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:
         A tuple consisting of `values` and `indexes`.
@@ -6100,53 +6586,19 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
 def expand(input_x, size):
     r"""
-    Returns a new tensor where the dimension of size is expanded to a larger size.
-
-    Note:
-        - 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): 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:
-        y (Tensor) - Tensor after expansion whose shape is `size`.
-
-    Raises:
-        TypeError: If `input_x` or `size` is not Tensor.
-        TypeError: If the type of `size` is not one of the following dtype: int16, int32, int64.
-        ValueError: If the size of `size` is less than the size of `input_x.shape`.
-        ValueError: If `size` is not a 1-D tensor.
-        ValueError: If the expanded `size` is not equal to the existing shape of `input_x` at a dimension
-            that is not 1.
-        ValueError: If the expanded `size` < 0 and it is in a leading position, corresponding to
-            a non-existing dimension in `input_x`.
-        ValueError: If the number of elements of output is more than 1000000.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> 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)
-        [[2. 2. 2. 2.]
-         [3. 3. 3. 3.]
-         [4. 4. 4. 4.]]
+    :func:`mindspore.ops.expand` will be deprecated in the future.
+    Please use :func:`mindspore.ops.broadcast_to` instead.
     """
     expand_op = _get_cache_prim(Expand)()
     return expand_op(input_x, size)
 
 
-@constexpr
+@_primexpr
 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, validator.EQ, 'fold')
+    validator.check_int(len(param), 2, validator.EQ, param_name, 'fold')
     if param_name == "padding":
         validator.check_non_negative_int_sequence(param, param_name, 'fold')
     else:
@@ -6155,40 +6607,61 @@ def _check_fold_param(param, param_name):
 
 
 def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
-    """
+    r"""
     Combines an array of sliding local blocks into a large containing tensor.
 
+    Consider a batched input tensor of shape :math:`(N, C \times \prod(\text{kernel_size}), L)` ,
+    where :math:`N` is the batch dimension, :math:`C \times \prod(\text{kernel_size})` is the
+    total number of values within each block (a block has :math:`\prod(\text{kernel_size})` spatial
+    locations each containing a `C`-channeled vector), and :math:`L` is the total number of such blocks:
+
+    .. math::
+        L = \prod_d \left\lfloor\frac{\text{output_size}[d] + 2 \times \text{padding}[d] %
+            - \text{dilations}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{strides}[d]} + 1\right\rfloor,
+
+    where :math:`d` is over all spatial dimensions.
+
+    Therefore, `output_size` is the spatial shape of the large containing tensor of the sliding local blocks.
+
+    The `dilation`, `padding` and `stride` arguments specify how the sliding blocks are retrieved.
+
     .. warning::
-        - Currently, only 4-D output tensors (batched image-like tensors) are supported.
+        - The input must be a 3-dimensional Tensor with shape
+          :math:`(N, C \times \prod(\text{kernel_size}), L)` .
+        - The output must be a 4-dimensional Tensor with shape
+          :math:`(N, C, output\_size[0], output\_size[1], ...)` .
 
     Args:
-        input (Tensor): 4-D Tensor with data type float16 or float32.
+        input (Tensor): 3-D Tensor, supported dtypes: float16, float32, float64, complex64 and complex128.
         output_size (Tensor): 1D tensor with `2` elements of data type int.
         kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
             for height and width. If type is int, it means that height equal with width. Must be specified.
         dilation (Union[int, tuple[int], list[int]], optional): The size of the dilation, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 1.
+            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 size of the padding, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 0.
+            for height and width. If type is int, it means that height equal with width. Default: ``0`` .
         stride (Union[int, tuple[int], list[int]], optional): The size of the stride, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: 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 Tensor is (N, C, H, W).
+        A Tensor, with same type as `input` . And its shape is as described above.
 
     Raises:
         TypeError: If `kernel_size`, `dilation`, `padding`, `stride` data type is not int, tuple or list.
         ValueError: If `kernel_size`, `dilation`, `stride` value is not
             greater than zero or elements number more than `2`.
         ValueError: If `padding` value is less than zero or elements number more than `2`.
-        ValueError: If `input.shape[2] != kernel_size[0] * kernel_size[1]`.
-        ValueError: If `input.shape[3]` does not match the calculated number of sliding blocks.
+        ValueError: If `input.shape[1] != kernel_size[0] * kernel_size[1]`
+        ValueError: If `input.shape[2]` does not match the calculated number of sliding blocks.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(input_data=np.random.rand(16, 16, 4, 25), dtype=mstype.float32)
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(input_data=np.random.rand(16, 64, 25), dtype=mstype.float32)
         >>> output_size = Tensor(input_data=[8, 8], dtype=mstype.int32)
         >>> output = ops.fold(x, output_size, [2, 2], [2, 2], [2, 2], [2, 2])
         >>> print(output.shape)
@@ -6199,10 +6672,14 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
     padding = _check_fold_param(padding, "padding")
     stride = _check_fold_param(stride, "stride")
     fold_op = _get_cache_prim(Col2Im)(kernel_size, dilation, padding, stride)
+    input_shape = ops.shape(input)
+    k = kernel_size[0] * kernel_size[-1]
+    r_shape = input_shape[:1] + (-1, k) + input_shape[-1:]
+    input = ops.reshape(input, r_shape)
     return fold_op(input, output_size)
 
 
-@constexpr
+@_primexpr
 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')
@@ -6216,32 +6693,60 @@ def _check_unfold_params(param, param_name, param_size):
 
 
 def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
-    """
-    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.
+    r"""
+    Extracts sliding local blocks from a batched input tensor.
+
+    Consider a batched input tensor of shape :math:`(N, C, *)`,
+    where :math:`N` is the batch dimension, :math:`C` is the channel dimension,
+    and :math:`*` represent arbitrary spatial dimensions. This operation flattens
+    each sliding `Kernel_size`- sized block within the spatial dimensions
+    of input `x` into a column (i.e., last dimension) of a 3-D output
+    tensor of shape :math:`(N, C \times \prod(\text{kernel_size}), L)`, where
+    :math:`C \times \prod(\text{kernel_size})` is the total number of values
+    within each block (a block has :math:`\prod(\text{kernel_size})` spatial
+    locations each containing a `C`-channeled vector), and :math:`L` is
+    the total number of such blocks:
+
+    .. math::
+        L = \prod_d \left\lfloor\frac{\text{spatial_size}[d] + 2 \times \text{pads}[d] %
+            - \text{dilations}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{strides}[d]} + 1\right\rfloor,
+
+    where :math:`\text{spatial_size}` is formed by the spatial dimensions
+    of input `x` (:math:`*` above), and :math:`d` is over all spatial
+    dimensions.
+
+    Therefore, indexing `output` at the last dimension (column dimension)
+    gives all values within a certain block.
+
+    The `dilation`, `padding` and `stride` arguments specify
+    how the sliding blocks are retrieved.
+
+    .. warning::
+        - The output is a 3-dimensional Tensor whose shape is
+          :math:`(N, C \times \prod(\text{kernel_size}), L)` .
 
     .. warning::
-        - Currently, only 4-D input tensors (batched image-like tensors) are supported.
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): 4-D Tensor. Support all real number data type.
+        input (Tensor): 4-D Tensor, supported dtypes: float16, float32, float64, complex64 and complex128.
         kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
             for height and width. If type is int, it means that height equal with width. Must be specified.
         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.
+            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
         padding (Union[int, tuple[int], list[int]], optional): The pad of the window, that must be
             a tuple/list of one or two `int` for height and width.
             If one int, pad_height = pad_width.
             If two int, pad_height = padding[0], pad_width = padding[1].
-            Default: 0.
+            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.
+            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`.
+        A Tensor, with same type as `input` . And its shape is as described above.
 
     Raises:
-        TypeError: If any data type of `kernel_size`, `stride`, `dilation`, `kernel_size` is not int, tuple or list.
+        TypeError: If any data type of `kernel_size`, `stride`, `dilation`, `padding` is not int, tuple or list.
         ValueError: If `kernel_size`, `dilation`, `stride` value is not
             greater than zero or elements number more than `2`.
         ValueError: If `padding` value is less than zero.
@@ -6250,23 +6755,30 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> 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, 4, 9, 900)
+        (4, 36, 900)
     """
     kernel_size = _check_unfold_params(kernel_size, "kernel_size", [1, 2])
     dilation = _check_unfold_params(dilation, "dilation", [1, 2])
-    padding = _check_unfold_params(padding, "padding", [1, 2, 4])
+    padding = _check_unfold_params(padding, "padding", [1, 2])
     stride = _check_unfold_params(stride, "stride", [1, 2])
     unfold_op = _get_cache_prim(Im2Col)(ksizes=kernel_size,
                                         strides=stride,
                                         dilations=dilation,
                                         pads=padding)
-    return unfold_op(input)
+    tmp = unfold_op(input)
+    tmp_shape = ops.shape(tmp)
+    out_shape = tmp_shape[:1] + (-1,) + tmp_shape[-1:]
+    out = ops.reshape(tmp, out_shape)
+    return out
 
 
-@constexpr
+@_primexpr
 def _check_diagonal_axes(dim1, dim2, x_ndim):
     """Check the parameters of unfold op."""
     axes = validator.check_axis_valid((dim1, dim2), x_ndim)
@@ -6286,13 +6798,13 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     Args:
         input (Tensor): Array from which the diagonals are taken.
         offset (int, optional): Offset of the diagonal from the main diagonal.
-            Can be positive or negative. Defaults: 0.
+            Can be positive or negative. Default: ``0`` .
         dim1 (int, optional): Axis to be used as the first axis of the 2-D
             sub-arrays from which the diagonals should be taken. Defaults to
-            first axis (0).
+            first axis (0). Default: ``0`` .
         dim2 (int, optional): Axis to be used as the second axis of the 2-D
             sub-arrays from which the diagonals should be taken. Defaults to
-            second axis (1).
+            second axis (1). Default: ``1`` .
 
     Returns:
         Tensor, if `input` is 2-D, then `input` 1-D array containing the diagonal. If
@@ -6300,12 +6812,15 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
         and a new axis inserted at the end corresponding to the diagonal.
 
     Raises:
+        TypeError: if `dim1` or `dim2` are not an int.
         ValueError: if the input tensor has less than two dimensions.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> x = Tensor([[0, 1], [2, 3]], mstype.float32)
         >>> output = ops.diagonal(x)
         >>> print(output)
@@ -6314,11 +6829,13 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     x_ndim = input.ndim
     if x_ndim < 2:
         raise ValueError(f"ops.diagonal requires an array of at least two dimensions")
+    _check_attr_dtype("dim1", dim1, [int], "diagonal")
+    _check_attr_dtype("dim2", dim2, [int], "diagonal")
     dtype = input.dtype
 
     axes = _check_diagonal_axes(dim1, dim2, x_ndim)
     perm = ()
-    for i in np.arange(x_ndim):
+    for i in ms_arrange(x_ndim):
         if i not in axes:
             perm += (i,)
     perm += axes
@@ -6327,39 +6844,106 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     x_shape = input.shape
     n, m = x_shape[-2:]
 
-    fill_op = _get_cache_prim(P.Fill)()
-    e = _get_cache_prim(P.Eye)()(n, m, dtype)
+    e = ops.eye(n, m, dtype)
     if offset >= m or offset <= -n:
-        e = fill_op(dtype, (n, m), 0)
-    elif offset != 0:
+        zero_shape = x_shape[:-2] + (0,)
+        return ops.zeros(zero_shape, dtype)
+    if offset != 0:
         e = e.astype(mstype.float32)
         if offset > 0:
-            e_left = fill_op(mstype.float32, (n, offset), 0)
+            e_left = ops.fill(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)
+            e = ops.cat((e_left, e_right), 1).astype(dtype)
         elif offset < 0:
-            e_upper = fill_op(mstype.float32, (-offset, m), 0)
+            e_upper = ops.fill(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 = F.broadcast_to(e, x_shape)
+            e = ops.cat((e_upper, e_lower), 0).astype(dtype)
+    e = ops.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)
+    prod_val = ops.mul(input, e)
+    res = ops.ReduceSum()(prod_val.astype(mstype.float32), -1)
 
     begin = ()
-    for _ in np.arange((x_ndim - 2)):
+    for _ in ms_arrange(x_ndim - 2):
         begin += (0,)
-    last_dim_begin = np.max((0, -offset)).astype(np.int64)
+    last_dim_begin = builtins.max(0, -offset)
     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
+    last_dim_end = builtins.min(x_shape[-2], builtins.max(0, x_shape[-1] - offset)) - last_dim_begin
     if last_dim_end <= 0:
         return Tensor([])
     res_size += (last_dim_end,)
-    res = _get_cache_prim(P.Slice)()(res, begin, res_size)
+    res = ops.slice(res, begin, res_size)
     return res.astype(dtype)
 
 
+def _check_is_tensor(param_name, input, cls_name):
+    """Returns True if input is Tensor."""
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For {cls_name}, {param_name} must be a Tensor, but got {type(input)}.")
+
+
+@_primexpr
+def _check_diagonal_scatter_shape(diag_shape, src_shape):
+    if diag_shape != src_shape:
+        raise ValueError(f"For diagonal_scatter, the shape of src should equal to the shape of input diagonal,"
+                         f"but got src.shape {src_shape} and diagonal shape {diag_shape}.")
+
+
+def diagonal_scatter(input, src, offset=0, dim1=0, dim2=1):
+    """
+    `dim1` and `dim2` specify the two dimensions of `input`,
+    the elements in these two dimensions will be treated as elements of a matrix,
+    and `src` is embedded on the diagonal of the matrix.
+
+    Args:
+        input (Tensor): Input Tensor, whose dimension is larger than 1.
+        src (Tensor): The source Tensor to embed.
+        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.
+
+        dim1 (int, optional): Axis to be used as the first axis of the 2-D
+            sub-arrays from which the diagonals should be taken. Default: ``0`` .
+        dim2 (int, optional): Axis to be used as the second axis of the 2-D
+            sub-arrays from which the diagonals should be taken. Default: ``1`` .
+
+    Returns:
+        Tensor after embedding, has the same shape and dtype as `input`.
+
+    Raises:
+        TypeError: If `input` or `src` is not a Tensor.
+        TypeError: If `offset` , `dim1` or `dim2` is not an integer.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> input = ms.ops.zeros((3,3))
+        >>> src = ms.ops.ones(2)
+        >>> out = ms.ops.diagonal_scatter(input, src, 1, dim1=1, dim2=0)
+        >>> print(out)
+        [[0. 0. 0.]
+         [1. 0. 0.]
+         [0. 1. 0.]]
+    """
+    _check_is_tensor("input", input, "diagonal_scatter")
+    _check_is_tensor("src", src, "diagonal_scatter")
+    _check_is_int(offset, "offset", "diagonal_scatter")
+    _check_is_int(dim1, "dim1", "diagonal_scatter")
+    _check_is_int(dim2, "dim2", "diagonal_scatter")
+    input_diag = input.diagonal(offset, dim1, dim2)
+    _check_diagonal_scatter_shape(input_diag.shape, src.shape)
+    embed = ones_like(src)
+    embed = ops.diag_embed(embed, offset, dim1, dim2)
+    embed = input * embed
+    src = ops.diag_embed(src, offset, dim1, dim2)
+    return input + src - embed
+
+
 def lstsq(input, A):
     r"""
     Computes the solutions of the least squares and minimum norm problems of full-rank
@@ -6405,6 +6989,9 @@ def lstsq(input, A):
         ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[2,1,5],[3,5,1],[1,1,1]]),mindspore.float32)
         >>> a = Tensor(np.array([[10,5],[15,8],[7,4]]),mindspore.float32)
         >>> output = ops.lstsq(x, a)
@@ -6449,6 +7036,9 @@ def mvlgamma(input, p):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[3, 4, 5], [4, 2, 6]]), mindspore.float32)
         >>> y = ops.mvlgamma(x, p=3)
         >>> print(y)
@@ -6491,18 +7081,19 @@ def argwhere(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.
+    Stacks 1-D tensors as columns into a 2-D tensor. Tensors of other dimension are stacked as-is,
+    like :func:`mindspore.ops.hstack`.
 
     Args:
-        tensors (Union[Tensor, tuple, list]): A sequence of 1-D or 2-D tensors. All
+        tensors (Union[tuple[Tensor], list[Tensor]]): A sequence of 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.
+        TypeError: If `tensors` is not list or tuple.
+        TypeError: If element in `tensors` is not Tensor.
         ValueError: If `tensors` is empty.
 
     Supported Platforms:
@@ -6519,11 +7110,13 @@ def column_stack(tensors):
          [1 2]]
     """
     if not isinstance(tensors, (list, tuple)):
-        raise TypeError(f"For column_stack, the input must be list or tuple or tensor, but got {type(tensors)}.")
+        raise TypeError(f"For column_stack, the input must be list or tuple of tensors, but got {type(tensors)}.")
 
     trans_x = ()
     _expand_dims = _get_cache_prim(P.ExpandDims)()
     for tensor in tensors:
+        if not isinstance(tensor, Tensor):
+            raise TypeError(f"For column_stack, the input element must be tensor, but got {type(tensor)}.")
         if tensor.ndim < 1:
             tensor = _expand_dims(tensor, 0)
         if tensor.ndim == 1:
@@ -6531,7 +7124,7 @@ def column_stack(tensors):
         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)
+    _concat = _get_cache_prim(P.Concat)(1)
     return _concat(trans_x)
 
 
@@ -6542,7 +7135,7 @@ def hstack(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 (Union[tuple[Tensor], list[Tensor]]): A sequence of tensors. The
             tensors must have the same shape along all but the second axis, except
             1-D tensors which can be any length.
 
@@ -6550,7 +7143,8 @@ def hstack(tensors):
         Stacked Tensor, formed by stacking the given tensors.
 
     Raises:
-        TypeError: If `tensors` is not Tensor, list or tuple.
+        TypeError: If `tensors` is not list or tuple.
+        TypeError: If element in `tensors` is not Tensor.
         ValueError: If `tensors` is empty.
 
     Supported Platforms:
@@ -6569,6 +7163,8 @@ def hstack(tensors):
 
     tuple_of_tensor = ()
     for tensor in tensors:
+        if not isinstance(tensor, Tensor):
+            raise TypeError(f"For hstack, the input element must be tensor, but got {type(tensor)}.")
         if tensor.ndim < 1:
             tensor = expand_dims_(tensor, 0)
         tuple_of_tensor += (tensor,)
@@ -6588,7 +7184,7 @@ def _check_axis_valid(axis, ndim):
     to the built-in operator (non-negative, int or tuple).
     """
     if axis is None:
-        axis = F.make_range(ndim)
+        axis = ops.make_range(ndim)
         return axis
     if isinstance(axis, (tuple, list)):
         axis = tuple(map(lambda x: _check_check_axis_in_range(x, ndim), axis))
@@ -6630,16 +7226,17 @@ def movedim(x, source, destination):
 
     Args:
         x (Tensor): The tensor array whose axis should be reordered.
+            The dimension of `x` must not be 0.
         source (Union[int, sequence[int]]): Original positions of the
-            axis to move. These must be unique.
+            axis to move. The length of `source` and `destination` must be the same.
         destination (Union[int, sequence[int]]): Destination positions
-            for each of the original axis. These must also be unique.
+            for each of the original axis. The length of `source` and `destination` must be the same.
 
     Returns:
         Tensor, array with moved axis.
 
     Raises:
-        ValueError: If axis are out of the range of `[-a.ndim, a.ndim)`, or
+        ValueError: If axis are out of the range of `[-x.ndim, x.ndim)`, or
             if the axis contain duplicates.
 
     Supported Platforms:
@@ -6661,7 +7258,7 @@ def movedim(x, source, destination):
         >>> print(output.shape)
         (4, 3, 5)
     """
-    ndim = F.rank(x)
+    ndim = ops.rank(x)
     source = _check_axis_valid(source, ndim)
     destination = _check_axis_valid(destination, ndim)
     if len(source) != len(destination):
@@ -6693,7 +7290,7 @@ def moveaxis(x, source, destination):
     return movedim(x, source, destination)
 
 
-@constexpr
+@_primexpr
 def _check_swapaxes_axis(axes, ndim):
     return validator.check_swapaxes_axis(axes, ndim)
 
@@ -6725,7 +7322,7 @@ def swapaxes(input, axis0, axis1):
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapaxes(input, 0, 2)
         >>> print(output.shape)
-        (4,3,2)
+        (4, 3, 2)
     '''
     if not isinstance(input, Tensor):
         raise TypeError(f'For ops.swapaxes, parameter `input` must be Tensor, but got {type(input)}')
@@ -6736,7 +7333,7 @@ def swapaxes(input, axis0, axis1):
     if axis0 > axis1:
         axis0, axis1 = axis1, axis0
 
-    perm = F.make_range(0, input.ndim)
+    perm = ops.make_range(0, input.ndim)
     if axis1 + 1 < input.ndim:
         new_perm = perm[0:axis0] + perm[axis1:axis1 + 1] + \
                    perm[axis0 + 1:axis1] + perm[axis0:axis0 + 1] + perm[axis1 + 1:]
@@ -6775,9 +7372,9 @@ def swapdims(input, dim0, dim1):
         >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
         >>> output = ops.swapdims(input, 0, 2)
         >>> print(output.shape)
-        (4,3,2)
+        (4, 3, 2)
     '''
-    return F.swapaxes(input, dim0, dim1)
+    return ops.swapaxes(input, dim0, dim1)
 
 
 @constexpr
@@ -6786,9 +7383,9 @@ def _check_is_int(arg_value, arg_name, op_name):
     return arg_value
 
 
-@constexpr
+@_primexpr
 def _check_positive_int(arg_value, arg_name, op_name):
-    arg_value = validator.check_positive_int(arg_value, arg_name, op_name)
+    arg_value = validator.check_int_range(arg_value, 0, 2147483647, validator.INC_RIGHT, arg_name, op_name)
     return arg_value
 
 
@@ -6805,7 +7402,7 @@ def _cal_repeat_dims(x_rank, rep, expand_axis):
     return tuple(rep_dims)
 
 
-@constexpr
+@_primexpr
 def _cal_reshape(x_shape, rep, axis):
     x_reshape = list(x_shape)
     x_reshape[axis] *= rep
@@ -6819,9 +7416,9 @@ def repeat_interleave(input, repeats, axis=None):
     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.
+        repeats (Union[int, tuple, list, Tensor]): 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
@@ -6832,6 +7429,9 @@ def repeat_interleave(input, repeats, axis=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[0, 1, 2], [3, 4, 5]]), mindspore.int32)
         >>> output = ops.repeat_interleave(input, repeats=2, axis=0)
         >>> print(output)
@@ -6843,7 +7443,10 @@ def repeat_interleave(input, repeats, axis=None):
     if axis is None:
         input = input.reshape(-1)
         axis = 0
-    return repeat_elements(input, repeats, axis)
+    if isinstance(repeats, Tensor):
+        repeats = TensorToList()(repeats)
+    output = input.repeat(repeats, axis)
+    return output
 
 
 def repeat_elements(x, rep, axis=0):
@@ -6854,7 +7457,7 @@ def repeat_elements(x, rep, axis=0):
         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.
+        axis (int): The axis along which to repeat. Default: 0.
 
     Returns:
         One tensor with values repeated along the specified axis. If x has shape
@@ -6865,6 +7468,9 @@ def repeat_elements(x, rep, axis=0):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # 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)
@@ -6880,7 +7486,7 @@ def repeat_elements(x, rep, axis=0):
         [[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')
+    const_utils.check_type_valid(ops.dtype(x), mstype.number_type, 'input x')
     rep = _check_positive_int(rep, "rep", "repeat_elements")
     axis = _check_is_int(axis, "axis", "repeat_elements")
     shape_op = P.Shape()
@@ -6922,7 +7528,7 @@ def sequence_mask(lengths, maxlen=None):
         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.
+            type as elements in `lengths`. Default is ``None`` .
 
     Returns:
         One mask tensor of shape `lengths.shape + (maxlen,)` .
@@ -6936,6 +7542,8 @@ def sequence_mask(lengths, maxlen=None):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1: When maxlen is assigned
         >>> x = Tensor(np.array([1, 2, 3, 4]))
         >>> output = ops.sequence_mask(x, 5)
@@ -6970,7 +7578,7 @@ def sequence_mask(lengths, maxlen=None):
     to_tensor_op = P.ScalarToTensor()
     shape_op = P.Shape()
 
-    const_utils.check_type_valid(F.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
+    const_utils.check_type_valid(ops.dtype(lengths), [mstype.int64, mstype.int32], 'lengths')
     _check_sequence_mask_input_len(shape_op(lengths), "sequence_mask")
 
     if maxlen is None:
@@ -6996,6 +7604,35 @@ def top_k(input_x, k, sorted=True):
     return top_k_(input_x, k)
 
 
+def deepcopy(input_x):
+    """
+    Returns a deepcopy of input tensor.
+
+    Args:
+        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Returns:
+        Tensor, a deepcopy of `input_x`.
+
+    Raises:
+        TypeError: If `input_x` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
+        >>> output = ops.deepcopy(input)
+        >>> print(output)
+        [[0 1]
+         [2 1]]
+    """
+    _deepcopy = _get_cache_prim(P.Identity)()
+    return _deepcopy(input_x)
+
+
 __all__ = [
     'unique',
     'unique_with_pad',
@@ -7004,7 +7641,6 @@ __all__ = [
     'matrix_band_part',
     'padding',
     'fill',
-    'fill_',
     'fills',
     'tile',
     'size',
@@ -7031,6 +7667,8 @@ __all__ = [
     'tensor_slice',
     'strided_slice',
     'slice',
+    'slice_scatter',
+    'select_scatter',
     'cat',
     'concat',
     'stack',
@@ -7085,6 +7723,7 @@ __all__ = [
     'tril',
     'triu',
     'nonzero',
+    'is_nonzero',
     'matrix_diag',
     'matrix_diag_part',
     'matrix_set_diag',
@@ -7112,6 +7751,7 @@ __all__ = [
     'fold',
     'unfold',
     'diagonal',
+    'diagonal_scatter',
     'lstsq',
     'mvlgamma',
     'swapaxes',
@@ -7128,6 +7768,7 @@ __all__ = [
     'moveaxis',
     'aminmax',
     'sort',
-    'top_k'
+    'top_k',
+    'deepcopy'
 ]
 __all__.sort()