mindspore 2.1.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.11__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/function/array_func.py

@@ -26,8 +26,7 @@ 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
@@ -65,8 +64,6 @@ from mindspore.ops._utils.utils import ms_arrange
 tuple_to_tensor_ = TupleToTensor()
 eye_ = P.Eye()
 fills_ = Fills()
-fill_ = P.Fill()
-fillv2_ = P.FillV2()
 ones_ = P.Ones()
 ones_like_ = P.OnesLike()
 tile_ = P.Tile()
@@ -115,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:
@@ -151,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):
@@ -240,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
@@ -653,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.
 
@@ -662,27 +660,28 @@ def one_hot(indices, depth, on_value, off_value, axis=-1):
 
     Note:
         If the input indices is rank `N`, the output will have rank `N+1`. The new axis is created at dimension `axis`.
+        On Ascend, if `on_value` is Int64 dtype, `indices` must be Int64 dtype.
 
     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`.
-            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,
+        on_value(Union[Tensor, int, float], optional): A value to fill in output when `indices[j] = i`.
+            Data type must be int32, int64, float16 or float32. 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`` .
 
     Returns:
-        Tensor, one-hot tensor. Tensor of shape :math:`(X_0, \ldots, X_{axis}, \text{depth} ,X_{axis+1}, \ldots, X_n)`.
+        Tensor, one-hot tensor. Tensor of shape :math:`(X_0, \ldots, X_{axis}, \text{depth} ,X_{axis+1}, \ldots, X_n)`,
+        and it has the same data type as `on_value`.
 
     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.
@@ -716,8 +715,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.1/api_python/mindspore.html#mindspore.dtype>`_ and
-            `number <https://www.mindspore.cn/docs/en/r2.1/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.
 
@@ -743,10 +742,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.
 
@@ -788,7 +788,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):
@@ -839,7 +839,7 @@ 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.
@@ -911,12 +911,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_)
 
 
@@ -952,7 +952,7 @@ def ones(shape, dtype=None):  # pylint: disable=redefined-outer-name
          [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])
@@ -993,7 +993,7 @@ def ones_like(input, *, dtype=None):
         [[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)
@@ -1028,7 +1028,7 @@ def zeros(size, dtype=None):  # pylint: disable=redefined-outer-name
         [[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):
@@ -1074,9 +1074,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
 
 
@@ -1147,7 +1148,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):
@@ -1455,7 +1457,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.1/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
@@ -1607,7 +1609,7 @@ def reshape(input, shape):
 
 
 def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
-    """
+    r"""
     Reverses variable length slices.
 
     Args:
@@ -1621,7 +1623,12 @@ def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
 
     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``
@@ -1724,12 +1731,16 @@ def flatten(input, order='C', *, start_dim=1, end_dim=-1):
     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) or \
-        isinstance(start_dim, bool) or isinstance(end_dim, bool):
+            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)
+        x_rank = rank_(input)
+        # If input is a 0-dimensional Tensor, a 1-dimensional Tensor will be returned.
+        if x_rank in (0, 1):
+            return reshape_(input, (-1,))
+        perm = ops.make_range(0, x_rank)
+        new_order = ops.tuple_reversed(perm)
         input = _get_cache_prim(P.Transpose)()(input, new_order)
 
     # Handle the default case.
@@ -1911,15 +1922,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)
@@ -2010,9 +2021,7 @@ 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.
@@ -2156,13 +2165,11 @@ def concat(tensors, axis=0):
     Alias for :func:`mindspore.ops.cat()`.
 
     Tutorial Examples:
-        - `Tensor - Tensor Operation <https://mindspore.cn/tutorials/en/r2.1/beginner/tensor.html#tensor-operation>`_
-        - `FGSM Network Adversarial Attack - Implementing FGSM
-          <https://mindspore.cn/tutorials/application/en/r2.1/cv/fgsm.html#implementing-fgsm>`_
+        - `Tensor - Tensor Operation <https://mindspore.cn/tutorials/en/r2.2/beginner/tensor.html#tensor-operation>`_
         - `Vision Transformer Image Classification - Building ViT as a whole
-          <https://mindspore.cn/tutorials/application/en/r2.1/cv/vit.html#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.1/nlp/sentiment_analysis.html#dense>`_
+          <https://mindspore.cn/tutorials/application/en/r2.2/nlp/sentiment_analysis.html#dense>`_
     """
     return cat(tensors, axis)
 
@@ -2279,7 +2286,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
@@ -2357,18 +2365,19 @@ 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.
+        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:
@@ -2376,8 +2385,8 @@ def squeeze(input, axis=None):
 
     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:
@@ -2396,6 +2405,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)
 
@@ -2478,7 +2489,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
@@ -3486,11 +3496,12 @@ 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.1/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:
@@ -3512,6 +3523,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
         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``
@@ -3976,7 +3988,7 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         >>> 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)
@@ -3984,7 +3996,9 @@ def tensor_scatter_elements(input_x, indices, updates, axis=0, reduction="none")
         >>> reduction = "add"
         >>> output = ops.tensor_scatter_elements(input_x, indices, updates, axis, reduction)
         >>> print(output)
-        [[5, 2, 3], [5, 5, 14], [7, 15, 11]]
+        [[ 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)
@@ -4048,7 +4062,7 @@ 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):
@@ -4087,6 +4101,7 @@ def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
         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.
@@ -4115,23 +4130,13 @@ def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
     for _ in builtins.range(axis):
         index_tensor = index_tensor.expand_dims(0)
 
-    if index_shape == src_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)
-
-    for _ in builtins.range(axis):
-        src = src.expand_dims(0)
-    if axis == input_rank - 1:
-        src = src.broadcast_to(input.shape[0:axis] + src_shape)
-    else:
-        for _ in builtins.range(len(src_shape)):
-            index_tensor = index_tensor.expand_dims(-1)
-        src = src.broadcast_to(input.shape[0:axis] + (len(index),) + src_shape)
+    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)
-    output = tensor_scatter_elements(input, axis=axis, indices=index_tensor, updates=src)
-    return output
+    return tensor_scatter_elements(input, axis=axis, indices=index_tensor, updates=src)
 
 
 def select_scatter(input, src, axis, index):
@@ -4148,6 +4153,7 @@ def select_scatter(input, src, axis, index):
         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.
@@ -4169,6 +4175,9 @@ def select_scatter(input, src, axis, index):
           [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)
 
 
@@ -4437,7 +4446,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
@@ -4445,13 +4454,13 @@ 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]). Default: ``0``.
-        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`` .
+            value of k must be in (-x.shape[-2], x.shape[-1]).
+        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)
@@ -4501,7 +4510,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
@@ -4713,7 +4722,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)`,
@@ -4787,7 +4796,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)
@@ -5580,10 +5589,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
@@ -5592,8 +5601,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
 
 
@@ -5687,7 +5696,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.
@@ -6102,7 +6111,7 @@ 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)
@@ -6120,7 +6129,7 @@ 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.
@@ -6138,7 +6147,8 @@ 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: ``None`` .
+        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`` .
 
@@ -6174,14 +6184,20 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):    # pyl
         >>> 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):
@@ -6237,7 +6253,7 @@ 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.
@@ -6366,6 +6382,9 @@ def aminmax(input, *, axis=0, keepdims=False):
     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
 
 
@@ -6477,7 +6496,6 @@ def unsorted_segment_sum(input_x, segment_ids, num_segments):
     return unsorted_segment_sum_(input_x, segment_ids, num_segments)
 
 
-
 def topk(input, k, dim=None, largest=True, sorted=True):
     r"""
     Finds values and indices of the `k` largest or smallest entries along a given dimension.
@@ -6500,12 +6518,8 @@ def topk(input, k, dim=None, largest=True, sorted=True):
 
     If the two compared elements are the same, the one with the smaller index value is returned first.
 
-    Note:
-        Currently, Ascend/CPU supported all common data types except bool and complex type,
-        but GPU only supports float16, float32 currently.
-
     Args:
-        input (Tensor): Input to be computed.
+        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.
@@ -6523,6 +6537,7 @@ def topk(input, k, dim=None, largest=True, sorted=True):
         TypeError: If `sorted` is not a bool.
         TypeError: If `input` is not a Tensor.
         TypeError: If `k` is not an int.
+        TypeError: If dtype of `input` is not one of the following: float16, float32 or int32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -6574,50 +6589,8 @@ 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.
-        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:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> 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.]]
-        >>> input_x = Tensor(2, mindspore.int16)
-        >>> size = Tensor(np.array([1, 1]), mindspore.int32)
-        >>> y = ops.expand(input_x, size)
-        >>> print(y)
-        [[2]]
+    :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)
@@ -6636,20 +6609,30 @@ def _check_fold_param(param, param_name):
     return param
 
 
-@_primexpr
-def _check_fold_input(input):
-    """Check the rank of fold's input."""
-    if not isinstance(input, (Tensor, Tensor_)) or F.rank(input) != 3:
-        raise ValueError(
-            f"For array function 'fold', 'input' must be a 3-D tensor.")
-
-
 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::
-        - The input must be a 3-dimensional Tensor with shape :math:`(N, C \times H, W)` .
+        - 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): 3-D Tensor, supported dtypes: float16, float32, float64, complex64 and complex128.
@@ -6664,7 +6647,7 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
             for height and width. If type is int, it means that height equal with width. Default: ``1`` .
 
     Returns:
-        A Tensor, with same type as `input`.
+        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.
@@ -6687,16 +6670,15 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
         >>> print(output.shape)
         (16, 16, 8, 8)
     """
-    _check_fold_input(input)
     kernel_size = _check_fold_param(kernel_size, "kernel_size")
     dilation = _check_fold_param(dilation, "dilation")
     padding = _check_fold_param(padding, "padding")
     stride = _check_fold_param(stride, "stride")
     fold_op = _get_cache_prim(Col2Im)(kernel_size, dilation, padding, stride)
-    input_shape = F.shape(input)
+    input_shape = ops.shape(input)
     k = kernel_size[0] * kernel_size[-1]
     r_shape = input_shape[:1] + (-1, k) + input_shape[-1:]
-    input = F.reshape(input, r_shape)
+    input = ops.reshape(input, r_shape)
     return fold_op(input, output_size)
 
 
@@ -6767,7 +6749,7 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
         A Tensor, with same type as `input` . And its shape is as described above.
 
     Raises:
-        TypeError: If 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.
@@ -6793,9 +6775,9 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
                                         dilations=dilation,
                                         pads=padding)
     tmp = unfold_op(input)
-    tmp_shape = F.shape(tmp)
+    tmp_shape = ops.shape(tmp)
     out_shape = tmp_shape[:1] + (-1,) + tmp_shape[-1:]
-    out = F.reshape(tmp, out_shape)
+    out = ops.reshape(tmp, out_shape)
     return out
 
 
@@ -6849,7 +6831,7 @@ 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")
+        raise ValueError(f"For 'ops.diagonal', the original tensor requires at least two dimensions, but got {x_ndim}")
     _check_attr_dtype("dim1", dim1, [int], "diagonal")
     _check_attr_dtype("dim2", dim2, [int], "diagonal")
     dtype = input.dtype
@@ -6865,36 +6847,36 @@ 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 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)
 
 
@@ -7205,7 +7187,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))
@@ -7279,7 +7261,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):
@@ -7354,7 +7336,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:]
@@ -7395,7 +7377,7 @@ def swapdims(input, dim0, dim1):
         >>> print(output.shape)
         (4, 3, 2)
     '''
-    return F.swapaxes(input, dim0, dim1)
+    return ops.swapaxes(input, dim0, dim1)
 
 
 @constexpr
@@ -7406,7 +7388,7 @@ def _check_is_int(arg_value, arg_name, op_name):
 
 @_primexpr
 def _check_positive_int(arg_value, arg_name, op_name):
-    arg_value = validator.check_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
 
 
@@ -7507,7 +7489,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()
@@ -7599,7 +7581,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:
@@ -7662,7 +7644,6 @@ __all__ = [
     'matrix_band_part',
     'padding',
     'fill',
-    'fill_',
     'fills',
     'tile',
     'size',