mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/_extends/parse/standard_method.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,28 +17,36 @@
 """standard_method"""
 
 from __future__ import absolute_import
-from mindspore import Tensor, CSRTensor, COOTensor, RowTensor, ms_class
+from mindspore import Tensor, CSRTensor, COOTensor
 from mindspore import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore.ops.function.sparse_func import sparse_add
-from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
-    _count, _extend
+from mindspore.common import mutable
 import mindspore.common._monad as monad
+from mindspore.common.sparse_tensor import RowTensorInner
+from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
+    _extend, _dict_clear, _haskey, _update, _fromkeys
 
-from ..._checkparam import Validator as validator
+from ... import _checkparam as validator
+from ..._checkparam import check_is_number, check_reshape_shp, prepare_shape_for_squeeze, \
+    check_axis_in_range, check_axis_valid, check_and_canonicalize_axes
 from ...ops import functional as F
 from ...ops import operations as P
-from ...ops.composite import tail, core, MultitypeFuncGraph, env_get, hyper_add, \
+from ...ops import composite
+from ...ops.composite import tail, MultitypeFuncGraph, env_get, hyper_add, \
     zeros_like, ones_like, repeat_elements
 from ...ops.composite.multitype_ops import _constexpr_utils as const_utils
 from ...ops.composite.multitype_ops import _compile_utils as compile_utils
 from ...ops.operations.math_ops import Median
-from ...ops.operations._inner_ops import Format
+from ...ops.operations._inner_ops import Format, issubclass_
 from ...ops.operations import _csr_ops
-from ...ops.primitive import constexpr
+from ...ops.operations import _map_tensor_ops
+from ...ops.primitive import constexpr, _primexpr
 from ...common import dtype as mstype
+from ...ops.operations._sequence_ops import ListAppend, ListInsert, SequenceMax, SequenceMin, \
+    SequenceIndex
 
-__all__ = ['MultitypeFuncGraph', 'env_get', 'hyper_add', 'zeros_like', 'ones_like']
+__all__ = ['MultitypeFuncGraph', 'env_get',
+           'hyper_add', 'zeros_like', 'ones_like']
 
 shape_ = P.Shape()
 dtype_ = P.DType()
@@ -51,8 +59,6 @@ _reduce_sum_default = P.ReduceSum()
 _reduce_sum_keepdims = P.ReduceSum(True)
 _mean_keepdims = P.ReduceMean(True)
 _csr_mm = _csr_ops.CSRMM()
-_addcdiv = P.Addcdiv()
-_addcmul = P.Addcmul()
 
 itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
                 mstype.float16: 2, mstype.int16: 2, mstype.uint16: 2,
@@ -62,7 +68,7 @@ itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
 nan_tensor = Tensor(float('nan'), dtype=mstype.float32)
 
 
-def mean(x, axis=(), keep_dims=False):
+def mean(x, axis=None, keep_dims=False):
     """
     Reduces a dimension of a tensor by averaging all elements in the dimension.
 
@@ -91,14 +97,19 @@ def mean(x, axis=(), keep_dims=False):
     return reduce_mean(x, axis)
 
 
-def prod(x, axis=(), keep_dims=False):
+def ndimension(x):
+    """Return the number of tensor dimensions."""
+    return len(x.shape)
+
+
+def prod(input, axis=None, keep_dims=False):
     """
     Reduces a dimension of a tensor by product all elements in the dimension.
 
     Args:
-        x (Tensor): Input Tensor.
+        input (Tensor): Input Tensor.
         axis (Union[None, int, tuple(int), list(int)]): Dimensions of reduction,
-            when axis is None or empty tuple, reduce all dimensions. Default: ().
+            when axis is None or empty tuple, reduce all dimensions. Default: None.
         keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
 
     Returns:
@@ -115,41 +126,41 @@ def prod(x, axis=(), keep_dims=False):
         >>> print(output)
         6.0
     """
-    return F.prod(x, axis, keep_dims)
+    return F.prod(input, axis, keep_dims)
 
 
-def addcdiv(input_data, x1, x2, value):
+def addcdiv(input, tensor1, tensor2, value=1):
     """
-    Performs the element-wise division of tensor x1 by tensor x2,
+    Performs the element-wise division of tensor tensor1 by tensor tensor2,
     multiply the result by the scalar value and add it to input_data.
 
     Args:
-        input_data (Tensor): The tensor to be added.
-        x1 (Tensor): The numerator tensor.
-        x2 (Tensor): The denominator tensor.
-        value (Tensor): The multiplier for tensor x1/x2.
+        input (Tensor): The tensor to be added.
+        tensor1 (Tensor): The numerator tensor.
+        tensor1 (Tensor): The denominator tensor.
+        value (Union[Tensor, Number]): The multiplier for tensor1/tensor2. Default: 1.
 
     Returns:
-        Tensor, has the same shape and dtype as x1/x2.
+        Tensor, has the same shape and dtype as tensor1 / tensor2.
     """
-    return _addcdiv(input_data, x1, x2, value)
+    return F.addcdiv(input, tensor1, tensor2, value)
 
 
-def addcmul(input_data, x1, x2, value):
+def addcmul(input, tensor1, tensor2, value=1):
     """
-    Performs the element-wise product of tensor x1 and tensor x2,
+    Performs the element-wise product of tensor tensor1 and tensor tensor2,
     multiply the result by the scalar value and add it to input_data.
 
     Args:
-        input_data (Tensor): The tensor to be added.
-        x1 (Tensor): The tensor to be multiplied.
-        x2 (Tensor): The tensor to be multiplied.
-        value (Tensor): The multiplier for tensor x1*x2.
+        input (Tensor): The tensor to be added.
+        tensor1 (Tensor): The tensor to be multiplied.
+        tensor2 (Tensor): The tensor to be multiplied.
+        value (Union[Tensor, Number]): The multiplier for tensor1*tensor2. Default: 1.
 
     Returns:
-        Tensor, has the same shape and dtype as x1*x2.
+        Tensor, has the same shape and dtype as tensor1 * tensor2.
     """
-    return _addcmul(input_data, x1, x2, value)
+    return F.addcmul(input, tensor1, tensor2, value)
 
 
 def all_(x, axis=(), keep_dims=False):
@@ -171,6 +182,13 @@ def all_(x, axis=(), keep_dims=False):
     return reduce_all(x, axis)
 
 
+def angle(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.angle`.
+    """
+    return F.angle(x)
+
+
 def any_(x, axis=(), keep_dims=False):
     """
     Check any array element along a given axis evaluate to True.
@@ -189,12 +207,41 @@ def any_(x, axis=(), keep_dims=False):
     return reduce_any(x, axis)
 
 
-def atan2(x, y):
+def atan2(input, other):
     r"""
     Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
     Refer to :func:`mindspore.ops.atan2` for more details.
     """
-    return F.atan2(x, y)
+    return F.atan2(input, other)
+
+
+def bincount(x, weights=None, minlength=0):
+    r"""
+    For details, please refer to :func:`mindspore.ops.bincount`.
+    """
+    return F.bincount(x, weights, minlength)
+
+
+def H(x):
+    """Returns a view of a matrix (2-D tensor) conjugated and transposed."""
+    output = x.swapaxes(0, 1)
+    if x.dtype in (mstype.complex64, mstype.complex128):
+        return output.conj()
+    return output
+
+
+def histc(x, bins=100, min=0., max=0.):
+    """
+    For details, please refer to :func:`mindspore.ops.histc`.
+    """
+    return F.histc(x, bins, min, max)
+
+
+def geqrf(x):
+    """
+    For details, please refer to :func:`mindspore.ops.geqrf`.
+    """
+    return F.geqrf(x)
 
 
 def size_(x):
@@ -210,8 +257,6 @@ def size_(x):
     Returns:
         size(int).
     """
-    if not shape_(x):
-        return size_op_(x) + 1
     return size_op_(x)
 
 
@@ -262,6 +307,27 @@ def strides_(x):
     return strides
 
 
+def slogdet(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.slogdet`.
+    """
+    return F.slogdet(x)
+
+
+def chunk(x, chunks, axis=0):
+    r"""
+    For details, please refer to :func:`mindspore.ops.chunk`.
+    """
+    return F.chunk(x, chunks, axis)
+
+
+def tril(x, diagonal=0):
+    r"""
+    For details, please refer to :func:`mindspore.ops.tril`.
+    """
+    return F.tril(x, diagonal)
+
+
 def hasattr(x, attr):  # pylint: disable=redefined-builtin
     """
     Return whether an object has the attribute.
@@ -321,6 +387,89 @@ def minimum(x, y):
     return F.minimum(x, y)
 
 
+def multinomial(input, num_samples, replacement=True, seed=None):
+    r"""
+    Returns a tensor sampled from the multinomial probability distribution located in the corresponding
+    row of the input tensor.
+
+    Refer to :func:`mindspore.ops.multinomial` for more detail.
+    """
+    return F.multinomial(input, num_samples, replacement, seed)
+
+
+def tile(x, multiples):
+    r"""
+    Replicates an input tensor with given multiples times.
+
+    Creates a new tensor by replicating `input_x` `multiples` times. The i'th dimension of
+    output tensor has `input_x.shape[i] * multiples[i]` elements, and the values of `input_x`
+    are replicated `multiples[i]` times along the i'th dimension.
+
+    Note:
+        The length of `multiples` must be greater or equal to the length of dimension in `input_x`.
+
+    Args:
+        multiples (tuple[int]): The parameter that specifies the number of replications,
+            the parameter type is tuple, and the data type is int, i.e., :math:`(y_1, y_2, ..., y_S)`.
+            The length of `multiples` cannot be smaller than the length of the shape of `input_x`.
+            Only constant value is allowed.
+
+    Returns:
+        Tensor, has the same data type as the `input_x`. Suppose the length of `multiples` is `d`,
+        the dimension of `input_x` is `input_x.dim`, and the shape of `input_x` is :math:`(x_1, x_2, ..., x_S)`.
+
+        - If `input_x.dim = d`, then the shape of their corresponding positions can be multiplied, and
+          the shape of Outputs is :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_R)`.
+        - If `input_x.dim < d`, fill in multiple 1 in the length of the shape of `input_x` until their
+          lengths are consistent. Such as set the shape of `input_x` as :math:`(1, ..., x_1, x_2, ..., x_S)`,
+          then the shape of their corresponding positions can be multiplied, and the shape of Outputs is
+          :math:`(1*y_1, ..., x_S*y_R)`.
+
+    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`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
+        >>> input_x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
+        >>> multiples = (2, 3)
+        >>> output = input_x.tile(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 = input_x.tile(multiples)
+        >>> print(output)
+        [[[1. 2. 1. 2.]
+        [3. 4. 3. 4.]
+        [1. 2. 1. 2.]
+        [3. 4. 3. 4.]
+        [1. 2. 1. 2.]
+        [3. 4. 3. 4.]]
+        [[1. 2. 1. 2.]
+        [3. 4. 3. 4.]
+        [1. 2. 1. 2.]
+        [3. 4. 3. 4.]
+        [1. 2. 1. 2.]
+        [3. 4. 3. 4.]]]
+    """
+    return F.tile(x, multiples)
+
+
+def short(x):
+    """
+    Return a copy of the tensor, cast to int16 type, equivalent to self.astype(ms.int16).
+    """
+    return F.cast(x, mstype.int16)
+
+
 def transpose(x, *axis):
     r"""
     Return a view of the tensor with axes transposed.
@@ -395,10 +544,54 @@ def reshape(x, *shape):
         [ 3.6  0.4]
         [ 0.5 -3.2]]
     """
-    new_shape = check_reshape_shp_const(shape)
+    new_shape = check_reshape_shp(shape)
     return F.reshape(x, new_shape)
 
 
+def reshape_as(x, other):
+    """
+    Rearranges the input Tensor based on the `other` shape.
+    """
+    return F.reshape(x, other.shape)
+
+
+def reverse(x, axis):
+    """
+    Reverses specific dimensions of a tensor.
+
+    .. warning::
+        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.
+        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.
+
+    Outputs:
+        Tensor, has the same shape and type as `x`.
+
+    Raises:
+        TypeError: If `axis` is neither list nor tuple.
+        TypeError: If element of `axis` is not an int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
+        >>> output = ops.reverse(input_x, axis=[1])
+        >>> print(output)
+        [[4 3 2 1]
+         [8 7 6 5]]
+        >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
+        >>> output = ops.reverse(input_x, axis=[1, 0])
+        >>> print(output)
+        [[8 7 6 5]
+         [4 3 2 1]]
+    """
+    return F.reverse(x, axis)
+
+
 def reverse_sequence(x, seq_lengths, seq_dim, batch_dim=0):
     """
     Reverses variable length slices.
@@ -479,17 +672,21 @@ def ravel(x):
     return reshape(x, (-1,))
 
 
-def flatten(x, order='C'):
+def flatten(x, order='C', *, start_dim=0, end_dim=-1):
     r"""
-    Return a copy of the tensor collapsed into one dimension.
+    Flatten a tensor along dimensions from `start_dim` to `start_dim`.
 
     Args:
-        order (str, optional): Can choose between 'C' and 'F'. 'C' means to
-            flatten in row-major (C-style) order. 'F' means to flatten in column-major
-            (Fortran-style) order. Only 'C' and 'F' are supported. Default: 'C'.
+        x (Tensor): Input tensor.
+        order (str, optional): Only 'C' and 'F' are supported. 'C' means to flatten in row-major (C-style) order.
+            'F' means to flatten in column-major (Fortran-style) order. Default: 'C'.
+
+    Keyword Args:
+        start_dim (int, optional): The first dimension to flatten. Default: 0.
+        end_dim (int, optional): The last dimension to flatten. Default: -1.
 
     Returns:
-        Tensor, has the same data type as input.
+        Tensor. If `x` is a 0-dimensional, a 1-dimensional Tensor will be returned.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -497,6 +694,9 @@ def flatten(x, order='C'):
     Raises:
         TypeError: If `order` is not string type.
         ValueError: If `order` is string type, but not 'C' or 'F'.
+        TypeError: If `start_dim` or `end_dim` is not int.
+        ValueError: If `start_dim` is greater than `end_dim` after canonicalized.
+        ValueError: If `start_dim` or `end_dim` is not in range of [-x.dim, x.dim-1].
 
     Examples:
         >>> import numpy as np
@@ -506,58 +706,28 @@ def flatten(x, order='C'):
         >>> print(output.shape)
         (24,)
     """
-    order = check_flatten_order_const(order)
-    if order == 'C':
-        return F.reshape(x, (-1,))
-
-    perm = F.make_range(0, F.rank(x))
-    new_order = F.tuple_reversed(perm)
-    return F.reshape(F.transpose(x, new_order), (-1,))
+    return F.flatten(x, order, start_dim=start_dim, end_dim=end_dim)
 
 
-def swapaxes(x, axis1, axis2):
+def scatter(self, axis, index, src):
     """
-    Interchange two axes of a tensor.
-
-    Args:
-        axis1 (int): First axis.
-        axis2 (int): Second axis.
-
-    Returns:
-        Transposed tensor, has the same data type as the input.
-
-    Raises:
-        TypeError: If `axis1` or `axis2` is not integer.
-        ValueError: If `axis1` or `axis2` is not in the range of :math:`[-ndim, ndim-1]`.
+    Update the value in `src` to tensor according to the specified index.
+    """
+    return F.scatter(self, axis, index, src)
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
 
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> x = Tensor(np.ones((2,3,4), dtype=np.float32))
-        >>> output = x.swapaxes(0, 2)
-        >>> print(output.shape)
-        (4,3,2)
+def swapaxes(input, axis0, axis1):
+    """
+    Interchange two axes of a tensor.
     """
-    axis1, axis2 = check_swapaxes_axis_const((axis1, axis2), x.ndim)
+    return F.swapaxes(input, axis0, axis1)
 
-    if axis1 == axis2:
-        return x
-    if axis1 > axis2:
-        axis1, axis2 = axis2, axis1
-
-    perm = F.make_range(0, x.ndim)
-    new_perm = None
-    if axis2 + 1 < x.ndim:
-        new_perm = perm[0:axis1] + perm[axis2:axis2 + 1] + \
-                   perm[axis1 + 1:axis2] + perm[axis1:axis1 + 1] + perm[axis2 + 1:]
-    else:
-        new_perm = perm[0:axis1] + perm[axis2:axis2 + 1] + \
-                   perm[axis1 + 1:axis2] + perm[axis1:axis1 + 1]
 
-    return F.transpose(x, new_perm)
+def swapdims(x, dim0, dim1):
+    """
+    Interchange two dims of a tensor.
+    """
+    return F.swapdims(x, dim0, dim1)
 
 
 def squeeze(x, axis=None):
@@ -589,25 +759,31 @@ def squeeze(x, axis=None):
     if axis is None:
         return F.squeeze(x)
     # yield squeezed shape based on the axes
-    new_shape = prepare_shape_for_squeeze_const(shape, axis)
+    new_shape = prepare_shape_for_squeeze(shape, axis)
     return F.reshape(x, new_shape)
 
 
-def argmax(x, axis=None):
+def unbind(input, dim=0):
+    """For details, please refer to :func:`mindspore.ops.unbind`."""
+    return P.Unstack(axis=dim)(input)
+
+
+def argmax(x, axis=None, keepdims=False):
     """
-    Returns the indices of the maximum values along an axis.
+    Returns the indices of the maximum values of a tensor across a dimension.
 
     Args:
-        axis (int, optional): By default, the index is into
-            the flattened array, otherwise along the specified axis.
-            Defaults to None.
+        axis (Union[int, None], optional): The dimension to reduce.
+          If `axis` is None, the indices of the maximum value within the
+          flattened input will be returned. Default: None.
+        keepdims (bool, optional): Whether the output tensor retains the
+          specified dimension. Ignored if `axis` is None. Default: False.
 
     Returns:
-        Tensor, array of indices into the array. It has the same
-        shape as a.shape with the dimension along axis removed.
+        Tensor, indices of the maximum values across a dimension.
 
     Raises:
-        ValueError: if axis is out of range.
+        ValueError: if `axis` is out of range.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -619,17 +795,18 @@ def argmax(x, axis=None):
         >>> print(a.argmax())
         5
     """
-    # P.Argmax only supports float
-    x = x.astype(mstype.float32)
+    is_axis_none = False
     if axis is None:
         x = ravel(x)
         axis = 0
-    else:
-        axis = check_axis_in_range_const(axis, F.rank(x))
-    return P.Argmax(axis)(x)
+        is_axis_none = True
+    out = P.Argmax(axis, mstype.int64)(x)
+    if keepdims and not is_axis_none:
+        out = expand_dims(out, axis)
+    return out
 
 
-def argmin(x, axis=None):
+def argmin(x, axis=None, keepdims=False):
     """
     Returns the indices of the minimum values along an axis.
 
@@ -638,6 +815,8 @@ def argmin(x, axis=None):
         axis (int, optional): By default, the index is into
             the flattened array, otherwise along the specified axis.
             Defaults to None.
+        keepdims (boolean, optional): Whether the output tensor retains the specified
+            dimension. Ignored if `axis` is None. Default: False.
 
     Returns:
         Tensor, array of indices into the array. It has the same
@@ -656,15 +835,19 @@ def argmin(x, axis=None):
         >>> print(a.argmin())
         0
     """
-    # P.Argmax only supports float
+    # P.Argmin only supports float
     x = x.astype(mstype.float32)
+    is_axis_none = False
     if axis is None:
         x = ravel(x)
         axis = 0
+        is_axis_none = True
     else:
-        axis = check_axis_in_range_const(axis, F.rank(x))
-    # P.Argmin is currently not supported
-    return P.Argmax(axis)(F.neg_tensor(x))
+        axis = check_axis_in_range(axis, F.rank(x))
+    out = P.Argmin(axis)(x)
+    if keepdims and not is_axis_none:
+        out = expand_dims(out, axis)
+    return out
 
 
 def argmax_with_value(x, axis=0, keep_dims=False):
@@ -677,7 +860,7 @@ def argmin_with_value(x, axis=0, keep_dims=False):
     return F.min(x, axis, keep_dims)
 
 
-def median(x, global_median, axis=0, keep_dims=False):
+def median(input, global_median, axis=0, keep_dims=False):
     r"""
     Computes the median of input tensor.
 
@@ -685,9 +868,38 @@ def median(x, global_median, axis=0, keep_dims=False):
         When attr `global_median` is True, the second output Tensor value is meaningless.
 
     """
-    check_axis_in_range_const(axis, x.ndim)
+    check_axis_in_range(axis, input.ndim)
     median_ = Median(global_median, axis, keep_dims)
-    return median_(x)
+    return median_(input)
+
+
+def msort(x):
+    """
+    For details, please refer to :func:`mindspore.ops.msort`.
+    """
+    return F.msort(x)
+
+
+def mm(mat1, mat2):
+    """
+    For details, please refer to :func:`mindspore.ops.mm`.
+    """
+    return F.mm(mat1, mat2)
+
+
+def mT(x):
+    """
+    Returns a view of this tensor with the last two dimensions transposed.
+    x.mT is equivalent to x.transpose(-2, -1).
+    """
+    return swapaxes(x, -2, -1)
+
+
+def nan_to_num(x, nan=0.0, posinf=None, neginf=None):
+    """
+    For details, please refer to :func:`mindspore.ops.nan_to_num`.
+    """
+    return F.nan_to_num(x, nan, posinf, neginf)
 
 
 def cumsum(x, axis=None, dtype=None):
@@ -730,7 +942,7 @@ def cumsum(x, axis=None, dtype=None):
     if axis is None:
         x = x.ravel()
         axis = 0
-    check_axis_in_range_const(axis, x.ndim)
+    check_axis_in_range(axis, x.ndim)
     if dtype is not None:
         dtype = check_astype_dtype_const(dtype)
         if original_dtype != dtype:
@@ -752,12 +964,19 @@ def cummax(x, axis):
     return F.cummax(x, axis)
 
 
-def index_fill(x, dim, index, value):
+def index_fill(x, axis, index, value):
     """
-    Fills the elements under the dim dimension of the input Tensor with the input value
+    Fills the elements under the axis dimension of the input Tensor with the input value
     by selecting the indices in the order given in index.
     """
-    return F.index_fill(x, dim, index, value)
+    return F.index_fill(x, axis, index, value)
+
+
+def index_select(x, axis, index):
+    """
+    Returns a new tensor which indexes the `x` tensor along dimension `axis` using the entries in `index` .
+    """
+    return F.index_select(x, axis, index)
 
 
 def copy(x):
@@ -798,7 +1017,8 @@ def copy(x):
     return x
 
 
-def max(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disable=redefined-builtin
+def max(input, axis=None, keepdims=False, *, initial=None,  # pylint: disable=redefined-builtin
+        where=True, return_indices=False):  # pylint: disable=redefined-outer-name
     """
     Returns the maximum of a tensor or maximum along an axis.
 
@@ -808,17 +1028,21 @@ def max(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disa
             axes along which to operate. By default, flattened input is used. If
             this is a tuple of ints, the maximum is selected over multiple axes,
             instead of a single axis or all the axes as before.
-        keepdims (boolean, optional): defaults to False.
+        keepdims (bool, optional): defaults to False.
             If this is set to True, the axes which are reduced are left in the
             result as dimensions with size one. With this option, the result will
             broadcast correctly against the input array.
+
+    Keyword Args:
         initial (scalar, optional):
             The minimum value of an output element. Must be present to allow
             computation on empty slice.
-        where (boolean Tensor, optional): defaults to True.
+        where (bool Tensor, optional): defaults to True.
             A boolean array which is broadcasted to match the dimensions of array,
             and selects elements to include in the reduction. If non-default value
             is passed, initial must also be provided.
+        return_indices (bool, optional): Whether to return the index of the minimum value. Default: False.
+                If `axis` is a list or tuple of ints, it must be False.
 
     Returns:
         Tensor or scalar, maximum of input tensor. If `axis` is None, the result is a scalar
@@ -828,7 +1052,7 @@ def max(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disa
         TypeError: if the input is not a tensor.
 
     Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -839,11 +1063,17 @@ def max(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disa
         >>> print(output)
         3.0
     """
-    return compile_utils.reduce_(x, P.ReduceMax(keepdims), cmp_fn=F.maximum,
-                                 axis=axis, keepdims=keepdims, initial=initial, where=where)
+    if isinstance(axis, (list, tuple)):
+        return compile_utils.reduce_(input, P.ReduceMax(keepdims), cmp_fn=F.maximum,
+                                     axis=axis, keepdims=keepdims, initial=initial, where=where)
+    values, indices = F.max(input, axis, keepdims, initial=initial, where=where)
+    if not return_indices:
+        return values
+    return values, indices
 
 
-def min(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disable=redefined-builtin
+def min(input, axis=None, keepdims=False, *, initial=None,  # pylint: disable=redefined-builtin
+        where=True, return_indices=False):  # pylint: disable=redefined-outer-name
     """
     Returns the minimum of a tensor or minimum along an axis.
 
@@ -853,17 +1083,21 @@ def min(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disa
             axes along which to operate. By default, flattened input is used. If
             this is a tuple of ints, the minimum is selected over multiple axes,
             instead of a single axis or all the axes as before.
-        keepdims (boolean, optional): defaults to False.
+        keepdims (bool, optional): defaults to False.
             If this is set to True, the axes which are reduced are left in the
             result as dimensions with size one. With this option, the result will
             broadcast correctly against the input array.
+
+    Keyword Args:
         initial (scalar, optional):
             The maximum value of an output element. Must be present to allow
             computation on empty slice.
-        where (boolean Tensor, optional): defaults to True.
+        where (bool Tensor, optional): defaults to True.
             A boolean array which is broadcasted to match the dimensions of array,
             and selects elements to include in the reduction. If non-default value
             is passed, initial must also be provided.
+        return_indices (bool, optional): Whether to return the index of the minimum value. Default: False.
+                If `axis` is a list or tuple of ints, it must be False.
 
     Returns:
         Tensor or scalar, minimum of `a`. If axis is None, the result is a scalar
@@ -884,8 +1118,13 @@ def min(x, axis=None, keepdims=False, initial=None, where=True):  # pylint: disa
         >>> print(output)
         0.0
     """
-    return compile_utils.reduce_(x, P.ReduceMin(keepdims), cmp_fn=F.minimum,
-                                 axis=axis, keepdims=keepdims, initial=initial, where=where)
+    if isinstance(axis, (list, tuple)):
+        return compile_utils.reduce_(input, P.ReduceMin(keepdims), cmp_fn=F.minimum,
+                                     axis=axis, keepdims=keepdims, initial=initial, where=where)
+    values, indices = F.min(input, axis, keepdims, initial=initial, where=where)
+    if not return_indices:
+        return values
+    return values, indices
 
 
 def pow(x, y):  # pylint: disable=redefined-builtin
@@ -902,6 +1141,42 @@ def log(x):
     return F.log(x)
 
 
+def log10(input):
+    """
+    Calculate the base-10 logarithm of Tensor.
+    """
+    return F.log10(input)
+
+
+def log2(input):
+    """
+    Calculate the base-2 logarithm of Tensor.
+    """
+    return F.log2(input)
+
+
+def logaddexp(input, other):
+    """
+    Computes the logarithm of the sum of exponentiations of the inputs.
+    """
+    return F.logaddexp(input, other)
+
+
+def logaddexp2(input, other):
+    """
+    Computes the logarithm of the sum of exponentiations in base of 2 of the inputs.
+    """
+    return F.logaddexp2(input, other)
+
+
+def logsumexp(input, axis, keepdims=False):
+    """
+    Reduces a dimension of a tensor by calculating exponential for all elements in the dimension,
+    then calculate logarithm of the sum.
+    """
+    return F.logsumexp(input, axis, keepdims)
+
+
 def round_(x):
     """
     Returns half to even of a tensor element-wise.
@@ -909,11 +1184,84 @@ def round_(x):
     return F.round(x)
 
 
-def unique_consecutive(x, return_idx=False, return_counts=False, axis=None):
+def roll(x, shifts, dims):
+    """
+    Rolls the elements of a tensor along an axis.
+    """
+    dims = dims if dims is not None else 0
+    return F.Roll(shifts, dims)(x)
+
+
+def rot90(x, k, dims):
+    """
+    Rotate a n-D tensor by 90 degrees in the plane specified by dims axis.
+    """
+    return F.rot90(x, k, dims)
+
+
+def rad2deg(x):
+    """
+    Returns a new tensor with each of the elements of `x` converted from angles in radians to degrees.
+    """
+    return F.rad2deg(x)
+
+
+def deg2rad(x):
+    """
+    Calculates a new tensor with each of the elements of `x` converted from angles in degrees to radians.
+    """
+    return F.deg2rad(x)
+
+
+def dot(input, other):
+    r"""
+    For details, please refer to :func:`mindspore.ops.dot`.
+    """
+    return composite.dot(input, other)
+
+
+def copysign(x, other):
+    """
+    Create a new floating-point tensor with the magnitude of `x` and the sign of `other`, element-wise.
+    """
+    return F.copysign(x, other)
+
+
+def numel(input):
+    """
+    Returns a Scalar of type int that represents the total number of elements in the Tensor.
+    """
+    return F.numel(input)
+
+
+def permute(input, *axis):
+    """
+    Permutes the dimensions of the input tensor according to input permutation.
+    """
+    ndim = F.rank(input)
+    perm = check_transpose_axis_const(axis, ndim)
+    return F.permute(input, perm)
+
+
+def positive(input):
+    """
+    Return self Tensor.
+    """
+    return F.positive(input)
+
+
+def remainder(input, divisor):
+    """
+    Returns element-wise remainder of division.
+    """
+    return F.remainder(input, divisor)
+
+
+def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
     """
     Returns the elements that are unique in each consecutive group of equivalent elements in the input tensor.
     """
-    return F.unique_consecutive(x, return_idx, return_counts, axis)
+    return F.unique_consecutive(input, return_idx, return_counts, axis)
 
 
 def unique_with_pad(x, pad_num):
@@ -966,6 +1314,13 @@ def resize(x, *new_shape):
     return res.reshape(new_shape)
 
 
+def det(input):
+    """
+    Computes the determinant of one or more square matrices.
+    """
+    return F.det(input)
+
+
 def diagonal(x, offset=0, axis1=0, axis2=1):
     """
     Returns specified diagonals.
@@ -1001,7 +1356,8 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
     """
     ndim = x.ndim
     if ndim < 2:
-        const_utils.raise_value_error('diagonal requires an array of at least two dimensions')
+        const_utils.raise_value_error(
+            'diagonal requires an array of at least two dimensions')
     dtype = x.dtype
 
     axes = check_axis_valid((axis1, axis2), ndim)
@@ -1028,7 +1384,7 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
             e_upper = F.fill(dtype, (-offset, m), 0)
             e_lower = e[0:n + offset:1, ...]
             e = P.Concat(0)((e_upper, e_lower)).astype(dtype)
-    e = P.BroadcastTo(shape)(e)
+    e = F.broadcast_to(e, shape)
 
     prod_val = F.tensor_mul(x, e)
     res = F.reduce_sum(prod_val.astype(mstype.float32), -1)
@@ -1048,6 +1404,27 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
     return res.astype(dtype)
 
 
+def digamma(input):
+    """
+    Computes the logarithmic derivative of the gamma function on input.
+    """
+    return F.digamma(input)
+
+
+def lgamma(input):
+    """
+    Computes the natural logarithm of the absolute value of the gamma function on input.
+    """
+    return F.lgamma(input)
+
+
+def i0(x):
+    """
+    For details, please refer to :func:`mindspore.ops.i0`.
+    """
+    return F.i0(x)
+
+
 def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
     """
     Returns a boolean tensor where two tensors are element-wise equal within a tolerance.
@@ -1055,51 +1432,137 @@ def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
     return F.isclose(x1, x2, rtol, atol, equal_nan)
 
 
-def inv(x):
+def isneginf(input):
     """
-    Computes Reciprocal of input tensor element-wise.
+    Tests element-wise for negative infinity, returns result as bool array.
     """
-    return F.inv(x)
+    return F.isneginf(input)
 
 
-def invert(x):
+def isposinf(input):
     """
-    Flips all bits of input tensor element-wise.
+    Tests element-wise for positive infinity, returns result as bool array.
     """
-    return F.invert(x)
+    return F.isposinf(input)
 
 
-def trace(x, offset=0, axis1=0, axis2=1, dtype=None):
+def isreal(input):
     """
-    Returns the sum along diagonals of the array.
+    Tests element-wise for real number.
+    """
+    return F.isreal(input)
 
-    Args:
-        offset (int, optional): Offset of the diagonal from the main diagonal.
-            Can be positive or negative. Defaults to main diagonal.
-        axis1 (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).
-        axis2 (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.
-        dtype (:class:`mindspore.dtype`, optional): defaults to None. Overrides the dtype of the
-            output Tensor.
 
-    Returns:
-        Tensor, sum_along_diagonals.
+def flip(x, dims):
+    """
+    For details, please refer to :func:`mindspore.ops.flip`.
+    """
+    return F.flip(x, dims)
 
-    Raises:
-        ValueError: if the input tensor has less than two dimensions.
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+def fliplr(x):
+    """
+    For details, please refer to :func:`mindspore.ops.fliplr`.
+    """
+    return F.fliplr(x)
 
-    Examples:
-        >>> import mindspore.numpy as np
-        >>> x = np.eye(3)
+
+def flipud(x):
+    """
+    For details, please refer to :func:`mindspore.ops.flipud`.
+    """
+    return F.flipud(x)
+
+
+def float_power(x, exponent):
+    """
+    For details, please refer to :func:`mindspore.ops.float_power`.
+    """
+    return F.float_power(x, exponent)
+
+
+def fmod(x, other):
+    """
+    For details, please refer to :func:`mindspore.ops.fmod`.
+    """
+    return F.fmod(x, other)
+
+
+def is_floating_point(x):
+    """
+    For details, please refer to :func:`mindspore.ops.is_floating_point`.
+    """
+    return F.is_floating_point(x)
+
+
+def is_signed(x):
+    """
+    For details, please refer to :func:`mindspore.ops.is_signed`.
+    """
+    return x.dtype in mstype.signed_type
+
+
+def is_complex(x):
+    """
+    For details, please refer to :func:`mindspore.ops.is_complex`.
+    """
+    return F.is_complex(x)
+
+
+def inv(x):
+    """
+    Computes Reciprocal of input tensor element-wise.
+    """
+    return F.inv(x)
+
+
+def inverse(input):
+    """
+    Computes the inverse of a square matrix.
+    """
+    return F.inverse(input)
+
+
+def invert(x):
+    """
+    Flips all bits of input tensor element-wise.
+    """
+    return F.invert(x)
+
+
+def trace(x, offset=0, axis1=0, axis2=1, dtype=None):
+    """
+    Returns the sum along diagonals of the array.
+
+    Args:
+        offset (int, optional): Offset of the diagonal from the main diagonal.
+            Can be positive or negative. Defaults to main diagonal.
+        axis1 (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).
+        axis2 (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.
+        dtype (:class:`mindspore.dtype`, optional): defaults to None. Overrides the dtype of the
+            output Tensor.
+
+    Returns:
+        Tensor, sum_along_diagonals.
+
+    Raises:
+        ValueError: if the input tensor has less than two dimensions.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> x = np.eye(3)
         >>> print(x.trace())
         3.0
     """
+    if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
+        return F.trace(x)
     d = x.diagonal(offset, axis1=axis1, axis2=axis2)
     shape = d.shape
     if dtype is None:
@@ -1148,14 +1611,15 @@ def take(x, indices, axis=None, mode='clip'):
         [4 3 6]
     """
     if mode not in ('raise', 'wrap', 'clip'):
-        const_utils.raise_value_error('raise should be one of "raise", "wrap", or "clip"')
+        const_utils.raise_value_error(
+            'raise should be one of "raise", "wrap", or "clip"')
     if axis is None:
         a = x.ravel()
         axis = 0
     else:
         a = x
     ndim = a.ndim
-    axis = check_axis_in_range_const(axis, ndim)
+    axis = check_axis_in_range(axis, ndim)
 
     shape_a = a.shape
     shape_indices = indices.shape
@@ -1169,12 +1633,26 @@ def take(x, indices, axis=None, mode='clip'):
     shape_indices = expanded_shape(ndim, size_indices, axis)
     indices = indices.reshape(shape_indices)
     shape_indices = shape_ni + (indices.size,) + shape_nk
-    indices = P.BroadcastTo(shape_indices)(indices)
+    indices = F.broadcast_to(indices, shape_indices)
 
     res = F.gather_d(a, axis, indices)
     return res.reshape(shape_out)
 
 
+def _infer_out_shape(*shapes):
+    """
+    Returns shape of output after broadcasting. Raises ValueError if shapes cannot be broadcast.
+    """
+    shape_out = list()
+    max_len = ms_max([len(it) for it in shapes])
+    for i in range(max_len):
+        items = [it[i-(max_len-len(it))] if i - (max_len - len(it))
+                 >= 0 else 1 for it in shapes]
+        max_size = 0 if 0 in items else ms_max(items)
+        shape_out.append(max_size)
+    return tuple(shape_out)
+
+
 def choose(x, choices, mode='clip'):
     """
     Construct an array from an index array and a list of arrays to choose from.
@@ -1212,8 +1690,8 @@ def choose(x, choices, mode='clip'):
         [20 31 12  3]
     """
     if check_is_tensor(F.typeof(choices)):
-        shape_choice = infer_out_shape(x.shape, choices.shape[1:])
-        choices = P.BroadcastTo((choices.shape[0],) + shape_choice)(choices)
+        shape_choice = _infer_out_shape(x.shape, choices.shape[1:])
+        choices = F.broadcast_to(choices, (choices.shape[0],) + shape_choice)
     else:
         # broadcasts choices to the same shape if choices is a sequence
         choicelist = []
@@ -1223,27 +1701,29 @@ def choose(x, choices, mode='clip'):
                 choice = const_utils.make_tensor(choice)
             shapes += (choice.shape,)
             choicelist.append(choice)
-        shape_choice = infer_out_shape(x.shape, *shapes)
+        shape_choice = _infer_out_shape(x.shape, *shapes)
         tmp = []
         for choice in choicelist:
-            tmp.append(P.BroadcastTo(shape_choice)(choice))
+            tmp.append(F.broadcast_to(choice, shape_choice))
         choices = F.stack(tmp)
 
     if x.ndim == 0 or choices.ndim == 0:
         const_utils.raise_value_error('input cannot be scalars')
-    a = P.BroadcastTo(shape_choice)(x)
+    a = F.broadcast_to(x, shape_choice)
     dtype = choices.dtype
     # adjusts dtype for F.tensor_mul and F.gather_nd
     a = a.astype(mstype.int32)
     choices = choices.astype(mstype.int32)
-    a = compile_utils.check_indices(choices.shape[0], a, mode, allow_negative_index=False)
+    a = compile_utils.check_indices(
+        choices.shape[0], a, mode, allow_negative_index=False)
 
     grids = []
     ndim = len(a.shape)
     for i in range(ndim):
-        dim_grid = const_utils.make_tensor(F.make_range(a.shape[i]), mstype.int32)
+        dim_grid = const_utils.make_tensor(
+            F.make_range(a.shape[i]), mstype.int32)
         dim_shape = expanded_shape(ndim, a.shape[i], i)
-        dim_grid = P.BroadcastTo(a.shape)(dim_grid.reshape(dim_shape))
+        dim_grid = F.broadcast_to(dim_grid.reshape(dim_shape), a.shape)
         grids.append(dim_grid)
     grid = P.Stack(-1)(grids)
     indices = P.Concat(-1)((a.reshape(a.shape + (1,)), grid))
@@ -1278,6 +1758,12 @@ def searchsorted(x, v, side='left', sorter=None):
         >>> print(x.searchsorted(3))
         2
     """
+    def get_log2_size(size):
+        """Get log2 size"""
+        log2_res = F.log2(F.cast(Tensor(size), mstype.float32))
+        ceil_res = F.ceil(log2_res)
+        cast_res = F.cast(ceil_res, mstype.int64)
+        return cast_res
     if side not in ('left', 'right'):
         const_utils.raise_value_error('invalid value for keyword "side"')
     a = x.astype(mstype.float32)
@@ -1286,7 +1772,8 @@ def searchsorted(x, v, side='left', sorter=None):
     shape = v.shape
     if sorter is not None:
         if sorter.ndim != 1 or sorter.size != a.size:
-            const_utils.raise_value_error('sorter must be 1-D array with the same size as `a`')
+            const_utils.raise_value_error(
+                'sorter must be 1-D array with the same size as `a`')
         sorter = const_utils.make_tensor(sorter)
         sorter = sorter.reshape(sorter.shape + (1,))
         a = F.gather_nd(a, sorter)
@@ -1294,43 +1781,20 @@ def searchsorted(x, v, side='left', sorter=None):
     i = F.fill(mstype.int32, shape, 0)
     j = F.fill(mstype.int32, shape, a.size)
 
-    sort_range = F.make_range(get_log2_size(F.shape_mul(a.shape) + 1))
-    for _ in sort_range:
+    loop_num = get_log2_size(F.shape_mul(a.shape) + 1)
+    index = Tensor([0])
+    while index < loop_num:
         mid = (i - F.neg_tensor(j)) // 2
         mask = less_op(v, F.gather_nd(a, mid.reshape(mid.shape + (1,))))
         i = F.select(mask, i, mid)
         j = F.select(mask, mid, j)
+        index += 1
     return j
 
 
 def fill(x, value):
     """
-    Fills the array with a scalar value.
-
-    Note:
-        Unlike Numpy, tensor.fill() will always returns a new tensor, instead of
-        filling the original tensor.
-
-    Args:
-        value (Union[None, int, float, bool]): All elements of a will be assigned this value.
-
-    Returns:
-        Tensor, with the original dtype and shape as input tensor.
-
-    Raises:
-        TypeError: If input arguments have types not specified above.
-        ValueError: If `shape` has entries < 0.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> a = Tensor(np.arange(4).reshape((2,2)).astype('float32'))
-        >>> print(a.fill(1.0))
-        [[1. 1.]
-        [1. 1.]]
+    `Tensor.fill` is deprecated, please use `ops.fill` instead.
     """
     if value is None:
         if x.dtype not in (mstype.float16, mstype.float32, mstype.float64):
@@ -1344,7 +1808,7 @@ def fill(x, value):
 
 def fills(x, value):
     """
-    Create a tensor of the same shape and type as the input tensor and fill it with specified value.
+    `Tensor.fills` is deprecated, please use `ops.fill` instead.
     """
     return F.fills(x, value)
 
@@ -1384,70 +1848,24 @@ def ptp(x, axis=None, keepdims=False):
     if axis is None:
         axis = ()
     else:
-        check_axis_type(axis, True, True, False)
+        validator.check_axis_type(axis, True, True, False)
         axis = check_axis_valid(axis, x.ndim)
 
     return x.max(axis, keepdims) - x.min(axis, keepdims)
 
 
-def clip(x, xmin, xmax, dtype=None):
+def clamp(x, min=None, max=None):
     """
-    Clips (limits) the values in an array.
-
-    Given an interval, values outside the interval are clipped to the interval edges.
-    For example, if an interval of :math:`[0, 1]` is specified, values smaller than 0 become 0,
-    and values larger than 1 become 1.
-
-    Note:
-        Currently, clip with `nan` is not supported.
-
-    Args:
-        x (Tensor): Tensor containing elements to clip.
-        xmin (Tensor, scalar, None): Minimum value. If None, clipping is not performed
-            on lower interval edge. Not more than one of `xmin` and `xmax` may be None.
-        xmax (Tensor, scalar, None): Maximum value. If None, clipping is not performed
-            on upper interval edge. Not more than one of `xmin` and `xmax` may be None.
-            If `xmin` or `xmax` are tensors, then the three tensors will be broadcasted
-            to match their shapes.
-        dtype (:class:`mindspore.dtype`, optional): defaults to None. Overrides the dtype of the
-            output Tensor.
-
-    Returns:
-        Tensor, a tensor with the elements of `x`, but where values
-        < `xmin` are replaced with `xmin`, and those > `xmax` with `xmax`.
+    Clamps all elements in `x` into the range `[min, max]`.
+    """
+    return F.clamp(x, min, max)
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
 
-    Examples:
-        >>> from mindspore import Tensor
-        >>> x = Tensor([1, 2, 3, -4, 0, 3, 2, 0]).astype("float32")
-        >>> output = x.clip(0, 2)
-        >>> print(output)
-        [1 2 2 0 0 2 2 0]
-    """
-    if xmin is None and xmax is None:
-        const_utils.raise_value_error("One of max or min must be given.")
-    is_scalar = False
-    if xmin is not None:
-        xmin = const_utils.make_tensor(xmin, x.dtype)
-        if x.ndim == 0 and xmin.ndim == 0:
-            x = F.maximum(x.reshape((1,)), xmin).squeeze()
-        else:
-            x = F.maximum(x, xmin)
-    if xmax is not None:
-        xmax = const_utils.make_tensor(xmax, x.dtype)
-        if x.ndim == 0 and xmax.ndim == 0:
-            x = F.minimum(x.reshape((1,)), xmax).squeeze()
-        else:
-            x = F.minimum(x, xmax)
-    if is_scalar:
-        return x.squeeze()
-    if dtype is not None:
-        dtype = check_astype_dtype_const(dtype)
-        if dtype != x.dtype:
-            return x.astype(dtype)
-    return x
+def clip(x, min=None, max=None):
+    """
+    Clamps all elements in `x` into the range `[min, max]`.
+    """
+    return F.clamp(x, min, max)
 
 
 def var(x, axis=None, ddof=0, keepdims=False):
@@ -1545,16 +1963,16 @@ def std(x, axis=None, ddof=0, keepdims=False):
     return F.tensor_pow(x_var, 0.5)
 
 
-def gather_elements(x, dim, index):
+def gather_elements(input, dim, index):
     r"""
     Gathers elements along an axis specified by dim.
 
     Refer to :func:`mindspore.ops.gather_elements` for more detail.
     """
-    return F.gather_elements(x, dim, index)
+    return F.gather_elements(input, dim, index)
 
 
-def sum(x, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disable=redefined-builtin
+def sum(input, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disable=redefined-builtin
     """
     Return sum of array elements over a given axis.
 
@@ -1563,7 +1981,7 @@ def sum(x, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disa
         `extobj` are not supported.
 
     Args:
-        x (Union[int, float, bool, list, tuple, Tensor]): Elements to sum.
+        input (Union[int, float, bool, list, tuple, Tensor]): Elements to sum.
         axis (Union[None, int, tuple(int)]): Axis or axes along which a sum is performed. Default: None.
             If None, sum all of the elements of the input array.
             If axis is negative it counts from the last to the first axis.
@@ -1599,7 +2017,7 @@ def sum(x, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disa
         >>> print(input_x.sum(axis=1))
         [10. 35.]
     """
-    input_x = x.astype(mstype.int32) if x.dtype == mstype.bool_ else x
+    input_x = input.astype(mstype.int32) if input.dtype == mstype.bool_ else input
     dtype = input_x.dtype if dtype is None else dtype
     dtype = check_astype_dtype_const(dtype)
     if not isinstance(keepdims, int):
@@ -1609,12 +2027,10 @@ def sum(x, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disa
     if axis is None:
         axis = ()
     else:
-        axis = check_and_canonicalize_axes(axis, x.ndim)
+        axis = check_and_canonicalize_axes(axis, input.ndim)
 
     if not check_type_support(input_x.dtype, 'GPU', (mstype.float64, mstype.float32, mstype.float16)):
         input_x = input_x.astype(mstype.float32)
-    if 0 in x.shape:
-        x = const_utils.make_tensor([0], x.dtype)
     if keepdims:
         res = _reduce_sum_keepdims(input_x, axis)
     else:
@@ -1624,6 +2040,36 @@ def sum(x, axis=None, dtype=None, keepdims=False, initial=None):  # pylint: disa
     return res.astype(dtype)
 
 
+def sum_to_size(input, *size):
+    """
+    Sum `input` to the `size`. `size` must be expandable to the Tensor size.
+    """
+    if len(size) == 1 and isinstance(size[0], tuple):
+        size = size[0]
+    shape_input = input.shape
+    if len(size) > input.ndim:
+        raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_input}.")
+    if len(size) < input.ndim:
+        pre_axis = tuple(axis for axis in range(input.ndim - len(size)))
+        input = input.sum(pre_axis)
+    axes = []
+    for i, element in enumerate(size):
+        if element != input.shape[i] and element == 1:
+            axes.append(i)
+        elif element != input.shape[i]:
+            raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_input}.")
+    if axes:
+        return input.sum(tuple(axes), keepdims=True)
+    return input
+
+
+def nansum(input, axis=None, keepdims=False, *, dtype=None):
+    """
+    Computes sum of all elements, treating NaNs as zero.
+    """
+    return F.nansum(input, axis=axis, keepdims=keepdims, dtype=dtype)
+
+
 def repeat(x, repeats, axis=None):
     """
     Repeat elements of an array.
@@ -1671,7 +2117,7 @@ def repeat(x, repeats, axis=None):
         axis = 0
     if not isinstance(axis, int):
         const_utils.raise_type_error('axes should be integers')
-    check_axis_in_range_const(axis, x.ndim)
+    check_axis_in_range(axis, x.ndim)
     axis = axis + x.ndim if axis < 0 else axis
 
     if len(repeats) == 1:
@@ -1681,7 +2127,8 @@ def repeat(x, repeats, axis=None):
         return repeat_elements(x, repeats, axis)
     size = x.shape[axis]
     if len(repeats) != size:
-        const_utils.raise_value_error('operands could not be broadcast together')
+        const_utils.raise_value_error(
+            'operands could not be broadcast together')
     subs = P.Split(axis, size)(x)
     repeated_subs = []
     for sub_item, rep in zip(subs, repeats):
@@ -1690,6 +2137,13 @@ def repeat(x, repeats, axis=None):
     return P.Concat(axis)(repeated_subs)
 
 
+def repeat_interleave(x, repeats, dim=None):
+    """
+    For details, please refer to :func:`mindspore.ops.repeat_interleave`.
+    """
+    return F.repeat_interleave(x, repeats, dim)
+
+
 def hardshrink(x, lambd=0.5):
     r"""
     Apply the Hard Shrink function for a tensor. Calculates the output according to the input elements.
@@ -1728,9 +2182,33 @@ def hardshrink(x, lambd=0.5):
     return P.HShrink(lambd)(x)
 
 
-def soft_shrink(x, lambd=0.5):
+def heaviside(x, values):
+    r"""
+    For details, please refer to :func:`mindspore.ops.heaviside`.
+    """
+    return F.heaviside(x, values)
+
+
+def hypot(x, other):
+    r'''
+    For details, please refer to :func:`mindspore.ops.hypot`.
+    '''
+    return F.hypot(x, other)
+
+
+def soft_shrink(input, lambd=0.5):
     """Apply the soft shrink function for a tensor. Calculates the output according to the input elements."""
-    return F.SoftShrink(lambd)(x)
+    return F.soft_shrink(input, lambd)
+
+
+def matrix_determinant(input):
+    """Computes the determinant of one or more square matrices."""
+    return F.matrix_determinant(input)
+
+
+def log_matrix_determinant(input):
+    """Computes the sign and the log of the absolute value of the determinant of one or more square matrices."""
+    return F.log_matrix_determinant(input)
 
 
 def getitem(data, index):
@@ -1788,7 +2266,8 @@ def constant_round(*data):
     """Returns the rounded value of the constant."""
     for x in data:
         if x is None:
-            raise ValueError("For round(), the input should be a Tensor or 1-2 constants.")
+            raise ValueError(
+                "For round(), the input should be a Tensor or 1-2 constants.")
     return round(*data)
 
 
@@ -1803,7 +2282,8 @@ def ms_round(*data):
             return round_(x)
         return constant_round(x)
     if isinstance(data[0], Tensor) or isinstance(data[1], Tensor):
-        const_utils.raise_type_error("When applying round() to tensor, only one tensor is supported as input.")
+        const_utils.raise_type_error(
+            "When applying round() to tensor, only one tensor is supported as input.")
     return constant_round(*data)
 
 
@@ -1820,10 +2300,12 @@ def str_func(*data):
     if data_len == 0:
         return ''
     data = data[0]
-    if isinstance(data, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("str() does not support sparse tensor input.")
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "str() does not support sparse tensor input.")
     if not F.isconstant(data):
-        const_utils.raise_type_error("str() does not support non-constant input.")
+        const_utils.raise_type_error(
+            "str() does not support non-constant input.")
     return cast_to_str(data)
 
 
@@ -1840,23 +2322,29 @@ def bool_func(*data):
     if data_len == 0:
         return False
     data = data[0]
-    if isinstance(data, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("bool() does not support sparse tensor input.")
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "bool() does not support sparse tensor input.")
     if isinstance(data, (Tensor, Tensor_)):
         tensor_shape = F.shape(data)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
             return data != 0
-        const_utils.raise_value_error("The truth value of an array with several elements is ambiguous.")
+        const_utils.raise_value_error(
+            "The truth value of an array with more than one element is ambiguous.")
     if not F.isconstant(data):
-        return len(data) != 0
+        if hasattr(data, "__bool__"):
+            return data.__bool__()
+        if hasattr(data, "__len__"):
+            return len(data) != 0
+        return True
     return cast_to_bool(data)
 
 
 @constexpr
 def cast_to_int(*data):
     target = data[0]
-    if isinstance(target, Tensor_):
+    if isinstance(target, (Tensor, Tensor_)):
         target = Tensor(target, internal=True)
     if len(data) == 1:
         return int(target)
@@ -1871,16 +2359,23 @@ def int_func(*data):
     if data_len == 0:
         return 0
     target = data[0]
+    base = 10
+    if data_len == 2:
+        base = data[1]
+    if isinstance(target, (Tensor, Tensor_, int, float, bool)) and base == 10 and not F.isconstant(target):
+        return F.scalar_cast(target, mstype.int64)
     if not F.isconstant(target):
-        const_utils.raise_type_error("int() does not support non-constant input.")
-    if isinstance(target, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("int() does not support sparse tensor input.")
+        const_utils.raise_type_error(
+            "int() does not support non-constant input.")
+    if isinstance(target, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "int() does not support sparse tensor input.")
     return cast_to_int(*data)
 
 
 @constexpr
 def cast_to_float(data):
-    if isinstance(data, Tensor_):
+    if isinstance(data, (Tensor, Tensor_)):
         data = Tensor(data, internal=True)
     return float(data)
 
@@ -1893,10 +2388,14 @@ def float_func(*data):
     if data_len == 0:
         return 0.0
     data = data[0]
+    if isinstance(data, (Tensor, Tensor_, int, float, bool)) and not F.isconstant(data):
+        return F.scalar_cast(data, mstype.float32)
     if not F.isconstant(data):
-        const_utils.raise_type_error("float() does not support non-constant input.")
-    if isinstance(data, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("float() does not support sparse tensor input.")
+        const_utils.raise_type_error(
+            "float() does not support non-constant input.")
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "float() does not support sparse tensor input.")
     return cast_to_float(data)
 
 
@@ -1908,14 +2407,21 @@ def list_func(*data):
     if data_len == 0:
         return F.make_list()
     data = data[0]
-    if isinstance(data, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("list() does not support single sparse tensor input.")
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "list() does not support single sparse tensor input.")
     if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
         data_type = F.typeof(data)
-        const_utils.raise_type_error(str(data_type) + " object is not iterable.")
+        const_utils.raise_type_error(
+            str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    ret = F.make_list()
+    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
+        ret = mutable([], True)
+        if F.is_dynamic_sequence_element_unknown(data):
+            return ret
+    else:
+        ret = F.make_list()
     for i in range(len(data)):
         ret = ret + F.make_list(data[i])
     return ret
@@ -1929,14 +2435,21 @@ def tuple_func(*data):
     if data_len == 0:
         return F.make_tuple()
     data = data[0]
-    if isinstance(data, (CSRTensor, COOTensor, RowTensor)):
-        const_utils.raise_type_error("tuple() does not support single sparse tensor input.")
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        const_utils.raise_type_error(
+            "tuple() does not support single sparse tensor input.")
     if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
         data_type = F.typeof(data)
-        const_utils.raise_type_error(str(data_type) + " object is not iterable.")
+        const_utils.raise_type_error(
+            str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    ret = F.make_tuple()
+    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
+        ret = mutable((), True)
+        if F.is_dynamic_sequence_element_unknown(data):
+            return ret
+    else:
+        ret = F.make_tuple()
     for i in range(len(data)):
         ret = ret + F.make_tuple(data[i])
     return ret
@@ -1962,7 +2475,8 @@ def get_max_min_data_len(*data):
     if isinstance(data, (dict, list, tuple)):
         len_data = len(data)
     else:
-        const_utils.raise_type_error("max() or min() does not support the data type.")
+        const_utils.raise_type_error(
+            "max() or min() does not support the data type.")
     return len_data
 
 
@@ -1971,6 +2485,11 @@ def get_tensor_num(data):
     tensor_num = 0
     for input_data in data:
         if isinstance(input_data, Tensor):
+            tensor_shape = F.shape(input_data)
+            tensor_shape_len = len(tensor_shape)
+            if tensor_shape_len != 0 and not (tensor_shape_len == 1 and tensor_shape[0] == 1):
+                const_utils.raise_value_error(
+                    "The truth value of an array with more than one element is ambiguous.")
             tensor_num = tensor_num + 1
     return tensor_num
 
@@ -1986,6 +2505,69 @@ def exist_tensor(data):
     return False
 
 
+def check_sequence_all_variable_scalar(x, str_info):
+    """Check whether x can be used in SequenceMax and SequenceMin"""
+    if F.is_sequence_shape_unknown(x):
+        if F.is_dynamic_sequence_element_unknown(x):
+            const_utils.raise_value_error(str_info + "() arg is an empty sequence.")
+        if not isinstance(x[0], (int, float)):
+            const_utils.raise_value_error(
+                "When the input to " + str_info + "() is dynamic length sequence, only support scalar type input")
+        return True
+    contain_variable_scalar = False
+    for i in x:
+        if not isinstance(i, (int, float)):
+            return False
+        if not contain_variable_scalar and not F.isconstant(i):
+            contain_variable_scalar = True
+    return contain_variable_scalar
+
+
+def get_data_type_str(input_data):
+    """Get the type of input."""
+    if isinstance(input_data, (int, float, bool)):
+        return "variable " + str(F.typeof(input_data))
+    return str(F.typeof(input_data))
+
+
+def check_isconstant(input_data, func_name):
+    """Check the input data of func is constant."""
+    if not F.isconstant(input_data):
+        const_utils.raise_type_error("The input of " + func_name + " only support Tensor, List, Tuple, constant Scalar,"
+                                                                   " but got " + get_data_type_str(input_data))
+
+
+def ms_max_one_element(x):
+    """Implementation of `max` which inputs has only one element."""
+    if isinstance(x, Tensor):
+        tensor_shape = F.shape(x)
+        tensor_shape_len = len(tensor_shape)
+        if tensor_shape_len == 0:
+            const_utils.raise_type_error(
+                "Cannot iterate over a scalar tensor.")
+        if tensor_shape_len >= 2:
+            const_utils.raise_value_error(
+                "The truth value of an array with more than one element is ambiguous.")
+        return x.max()
+    # Deal with Tensor in tuple or list
+    if isinstance(x, (list, tuple)):
+        if check_sequence_all_variable_scalar(x, "max"):
+            return SequenceMax()(x)
+        if len(x) == 0:
+            const_utils.raise_value_error("max() arg is an empty sequence.")
+        tensor_num = get_tensor_num(x)
+        if tensor_num == len(x):
+            return max_tensor(x)
+        if tensor_num != 0:
+            const_utils.raise_type_error(
+                "max() cannot contain both tensor and non-tensor type.")
+        if exist_tensor(x):
+            const_utils.raise_type_error(
+                "max() cannot support tensor in list or tuple nested now.")
+    check_isconstant(x, "max()")
+    return max_(x)
+
+
 def ms_max(*data):
     """Implementation of `max`."""
     len_data = get_max_min_data_len(data)
@@ -1993,25 +2575,21 @@ def ms_max(*data):
         const_utils.raise_type_error("max() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
-        if isinstance(x, Tensor):
-            return x.max()
-        # Deal with Tensor in tuple or list
-        if isinstance(x, (list, tuple)):
-            tensor_num = get_tensor_num(x)
-            if tensor_num == len(x):
-                return max_tensor(x)
-            if tensor_num != 0:
-                const_utils.raise_type_error("max() cannot contain both tensor and non-tensor type.")
-            if exist_tensor(x):
-                const_utils.raise_type_error("max() cannot support tensor in list or tuple nested now.")
-        return max_(x)
+        return ms_max_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
         if tensor_num == len_data:
             return max_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error("max() cannot contain both tensor and non-tensor type.")
+            const_utils.raise_type_error(
+                "max() cannot contain both tensor and non-tensor type.")
+        # exist tensor in list/tuple
+        if exist_tensor(data):
+            const_utils.raise_value_error(
+                "The truth value of an array with more than one element is ambiguous.")
+    for input_data in data:
+        check_isconstant(input_data, "max()")
     return max_(*data)
 
 
@@ -2042,6 +2620,37 @@ def min_list_tuple(seq1, seq2):
     return seq1
 
 
+def ms_min_one_element(x):
+    """Implementation of `min` which inputs has only one element."""
+    if isinstance(x, Tensor):
+        tensor_shape = F.shape(x)
+        tensor_shape_len = len(tensor_shape)
+        if tensor_shape_len == 0:
+            const_utils.raise_type_error(
+                "Cannot iterate over a scalar tensor.")
+        if tensor_shape_len >= 2:
+            const_utils.raise_value_error(
+                "The truth value of an array with more than one element is ambiguous.")
+        return x.min()
+    # Deal with Tensor in tuple or list
+    if isinstance(x, (list, tuple)):
+        if check_sequence_all_variable_scalar(x, "min"):
+            return SequenceMin()(x)
+        if len(x) == 0:
+            const_utils.raise_value_error("min() arg is an empty sequence.")
+        tensor_num = get_tensor_num(x)
+        if tensor_num == len(x):
+            return min_tensor(x)
+        if tensor_num != 0:
+            const_utils.raise_type_error(
+                "min() cannot contain both tensor and non-tensor type.")
+        if exist_tensor(x):
+            const_utils.raise_type_error(
+                "min() cannot support tensor in list or tuple nested now.")
+    check_isconstant(x, "min()")
+    return min_(x)
+
+
 def ms_min(*data):
     """Implementation of `min`."""
     len_data = get_max_min_data_len(data)
@@ -2049,25 +2658,21 @@ def ms_min(*data):
         const_utils.raise_type_error("min() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
-        if isinstance(x, Tensor):
-            return x.min()
-        # Deal with Tensor in tuple or list
-        if isinstance(x, (list, tuple)):
-            tensor_num = get_tensor_num(x)
-            if tensor_num == len(x):
-                return min_tensor(x)
-            if tensor_num != 0:
-                const_utils.raise_type_error("min() cannot contain both tensor and non-tensor type.")
-            if exist_tensor(x):
-                const_utils.raise_type_error("min() cannot support tensor in list or tuple nested now.")
-        return min_(x)
+        return ms_min_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
         if tensor_num == len_data:
             return min_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error("min() cannot contain both tensor and non-tensor type.")
+            const_utils.raise_type_error(
+                "min() cannot contain both tensor and non-tensor type.")
+        # exist tensor in list/tuple
+        if exist_tensor(data):
+            const_utils.raise_value_error(
+                "The truth value of an array with more than one element is ambiguous.")
+    for input_data in data:
+        check_isconstant(input_data, "min()")
     return min_(*data)
 
 
@@ -2079,7 +2684,13 @@ def ms_sum(*data):
     x = data[0]
     if not isinstance(x, Tensor) and not hasattr(x, "__ms_iter__"):
         data_type = F.typeof(x)
-        const_utils.raise_type_error(str(data_type) + " object is not iterable.")
+        const_utils.raise_type_error(
+            str(data_type) + " object is not iterable.")
+    if isinstance(x, Tensor):
+        tensor_shape = F.shape(x)
+        if len(tensor_shape) == 0:
+            const_utils.raise_type_error(
+                "Cannot iterate over a scalar tensor.")
     if isinstance(x, dict):
         x = x.keys()
     result = 0
@@ -2106,14 +2717,37 @@ def ms_len(data):
     return data.__len__()
 
 
-def floor(x):
-    """Implementation of `floor`."""
-    return x.__floor__()
+@constexpr
+def python_len_with_check(data):
+    """Return the result of python built-in len function with iterable check"""
+    if not hasattr(data, "__iter__"):
+        raise TypeError(str(type(data)) +
+                        " object is not iterable in graph mode.")
+    return len(data)
+
+
+def ms_len_with_iterable_check(data):
+    """Implementation of `len` with iterable check, used in len of condition."""
+    if not isinstance(data, Tensor) and F.isconstant(data):
+        return python_len_with_check(data)
+    if not hasattr(data, "__len__"):
+        type_str = str(F.typeof(data))
+        const_utils.raise_type_error(
+            type_str + " object is not iterable in graph mode.")
+    return data.__len__()
+
+
+def ms_next_with_dyn_input_check(it):
+    """Implementation of `next` with daynamic input check."""
+    if isinstance(it, (tuple, list)) and F.is_sequence_shape_unknown(it):
+        raise ValueError(f"For 'ListComprehension' syntax [i for i in x], "
+            f"input x can not be dynamic length list/tuple in graph mode")
+    return it.__ms_hasnext__()
 
 
-def trunc(x):
-    """Implementation of `trunc`."""
-    return x.__trunc__()
+def floor(x):
+    """Rounds a tensor down to the closest integer element-wise."""
+    return x.__floor__()
 
 
 def uadd(x):
@@ -2151,6 +2785,9 @@ def enumerate_(x, start=0):
         if check_is_tensor(x_type):
             for i in range(x.shape[0]):
                 ret += ((start + i, x[i]),)
+        elif F.is_sequence_shape_unknown(x):
+            const_utils.raise_value_error(
+                "For 'enumerate', the dynamic length input is unsupported in graph mode")
         else:
             ret = zip(range(start, start + len(x)), x)
     return ret
@@ -2158,22 +2795,27 @@ def enumerate_(x, start=0):
 
 def expand_tensor_as(x, y):
     """Expand tensor"""
-    return P.BroadcastTo(shape_(y))(x)
+    return F.broadcast_to(x, shape_(y))
 
 
 def broadcast_to(x, shape):
     """Broadcasts tensor to a given shape."""
-    return P.BroadcastTo(shape)(x)
+    return F.broadcast_to(x, shape)
 
 
 def expand_dims(x, axis):
     """
-    Insert a dimension of shape 1 at the specified axis of Tensor
+    Insert a dimension of shape 1 at the specified axis of Tensor.
     """
-    check_is_int(axis, 'axis')
+    validator.check_is_int(axis, 'axis')
     return P.ExpandDims()(x, axis)
 
 
+def unsqueeze(input, dim):
+    """For details, please refer to :func:`mindspore.ops.unsqueeze`."""
+    return P.ExpandDims()(input, dim)
+
+
 def masked_fill(x, mask, value):
     """
     Fills elements of Tensor with value where mask is True.
@@ -2191,12 +2833,12 @@ def col2im(*inputs):
     return F.col2im(*inputs)
 
 
-def narrow(x, axis, start, length):
+def narrow(input, axis, start, length):
     """
     Returns a narrowed tensor from input tensor.
     The dimension axis is input from start to start + length.
     """
-    return F.narrow(x, axis, start, length)
+    return F.narrow(input, axis, start, length)
 
 
 def to_csr(x):
@@ -2222,7 +2864,8 @@ def check_select_condition(cond_type):
     """
     if isinstance(cond_type, mstype.tensor_type):
         return
-    raise TypeError(f"For select, the argument condition should be Tensor, but got {cond_type}.")
+    raise TypeError(
+        f"For select, the argument condition should be Tensor, but got {cond_type}.")
 
 
 @constexpr
@@ -2262,6 +2905,13 @@ def view(x, *shape):
     return F.reshape(x, shape)
 
 
+def view_as(input, other):
+    """View self Tensor as the same shape as `other` ."""
+    if not isinstance(other, (Tensor, Tensor_)):
+        raise TypeError(f"For view_as, the input other must be a Tensor, but got {type(other)}")
+    return F.reshape(input, other.shape)
+
+
 def bitwise_and(x, y):
     """Returns bitwise `and` of two tensors element-wise."""
     return F.bitwise_and(x, y)
@@ -2277,11 +2927,42 @@ def bitwise_xor(x, y):
     return F.bitwise_xor(x, y)
 
 
+def bitwise_left_shift(x, y):
+    """Returns bitwise left shift of `x` by `other` bits."""
+    return F.bitwise_left_shift(x, y)
+
+
+def bitwise_right_shift(x, y):
+    """Returns bitwise right shift of `x` by `other` bits."""
+    return F.bitwise_right_shift(x, y)
+
+
 def exp(x):
     """Returns exponential of a tensor element-wise."""
     return F.exp(x)
 
 
+def real(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.real`.
+    """
+    return F.real(x)
+
+
+def rsqrt(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.rsqrt`.
+    """
+    return F.rsqrt(x)
+
+
+def reciprocal(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.reciprocal`.
+    """
+    return F.reciprocal(x)
+
+
 def sqrt(x):
     """Returns sqrt of a tensor element-wise."""
     return F.sqrt(x)
@@ -2297,6 +2978,11 @@ def sub(x, y):
     return F.sub(x, y)
 
 
+def t(input):
+    """Transposes a 2-D tensor."""
+    return F.t(input)
+
+
 def tan(x):
     """Returns tangent of `x`."""
     return F.tan(x)
@@ -2314,14 +3000,24 @@ def cosh(x):
     return F.cosh(x)
 
 
-def ger(x, y):
-    """Ger product of `x1` and `x2`.."""
-    return F.ger(x, y)
+def ger(input, vec2):
+    """Ger product of `input` and `vec2`."""
+    return F.ger(input, vec2)
+
+
+def gt(x, y):
+    """Compare the value of the input parameters :math:`x > y` element-wise."""
+    return F.gt(x, y)
+
+
+def ge(x, y):
+    """Compare the value of the input parameters :math:`x >= y` element-wise."""
+    return F.ge(x, y)
 
 
 def while_cond(x):
     """For while condition, if the condition is a tensor, the loop will not be unrolled"""
-    if F.issubclass_(F.typeof(x), F.typeof(mstype.tensor)):
+    if issubclass_(F.typeof(x), F.typeof(mstype.tensor)):
         is_cond = check_is_tensor_bool_cond(F.shape(x))
         if is_cond:
             return F.cast(x, mstype.bool_)
@@ -2395,11 +3091,34 @@ def unsorted_segment_prod(x, segment_ids, num_segments):
     return F.unsorted_segment_prod(x, segment_ids, num_segments)
 
 
-def nonzero(x):
+def negative(input):
+    r"""
+    Return a new tensor with the negative of the elements of input.
+    """
+    return F.neg(input)
+
+
+def nonzero(input):
     """
     Return a Tensor of the positions of all non-zero values.
     """
-    return F.nonzero(x)
+    return F.nonzero(input)
+
+
+def new_zeros(x, size, *, dtype=None):
+    r"""
+    Return a tensor of `size` filled with zeros. By default, the returned tensor has the same dtype as `x`.
+    """
+    _dtype = x.dtype if dtype is None else dtype
+    return F.zeros(size, dtype=_dtype)
+
+
+def new_ones(x, size, *, dtype=None):
+    r"""
+    Return a tensor of `size` filled with ones. By default, the returned tensor has the same dtype as `x`.
+    """
+    _dtype = x.dtype if dtype is None else dtype
+    return F.ones(size, dtype=_dtype)
 
 
 def diag(x):
@@ -2409,11 +3128,18 @@ def diag(x):
     return F.diag(x)
 
 
-def masked_select(x, mask):
+def diagflat(input, offset=0):
+    """
+    Creates a two-dimensional Tensor with the flattened input as a diagonal.
+    """
+    return F.diagflat(input, offset)
+
+
+def masked_select(input, mask):
     """
     Returns a new 1-D Tensor which indexes the input tensor according to the boolean mask.
     """
-    return F.masked_select(x, mask)
+    return F.masked_select(input, mask)
 
 
 def inplace_update(x, v, indices):
@@ -2438,21 +3164,23 @@ def coo_to_csr(x):
 
 def coo_to_dense(x):
     """convert coo to dense."""
-    zeros_tensor = F.zeros(x.shape, x.values.dtype)
+    zeros_tensor = F.zeros(x.shape, dtype=x.values.dtype)
     return F.tensor_scatter_update(zeros_tensor, x.indices, x.values)
 
 
 def coo_coalesce(x):
     """Returns the coalesced sparse tensor of the input."""
     shape = const_utils.make_tensor(x.shape)
-    res_indices, res_values, _ = P.Coalesce()(x.indices.transpose(), x.values, shape)
+    res_indices, res_values, _ = P.Coalesce()(
+        x.indices.transpose(), x.values, shape)
     return COOTensor(res_indices.transpose(), res_values, x.shape)
 
 
 def csr_to_coo(x):
     """convert csr to coo."""
     if x.ndim != 2:
-        const_utils.raise_value_error("Currently only support 2-D CSRTensor when converting to COOTensor.")
+        const_utils.raise_value_error(
+            "Currently only support 2-D CSRTensor when converting to COOTensor.")
     row_indices = F.csr2coo(x.indptr, x.values.shape[0])
     coo_indices = P.Stack(1)((row_indices, x.indices))
     return COOTensor(coo_indices, x.values, x.shape)
@@ -2463,7 +3191,7 @@ def csr_to_dense(x):
     return F.csr_to_dense(x)
 
 
-def random_categorical_(x, num_sample, seed=0, dtype=mstype.int64):
+def random_categorical(x, num_sample, seed=0, dtype=mstype.int64):
     r"""
     Generates random samples from a given categorical distribution tensor.
     Refer to :func:`mindspore.ops.random_categorical` for more detail.
@@ -2498,30 +3226,42 @@ def check_is_tuple_or_list_or_tensor(x, op_name, arg_name):
     """check whether x is list or tuple or tensor."""
     if isinstance(x, (mstype.List, mstype.Tuple, mstype.tensor_type)):
         return True
-    raise TypeError(f"For '{op_name}', the '{arg_name}' should be tuple or list or tensor, but got {x}.")
+    raise TypeError(
+        f"For '{op_name}', the '{arg_name}' should be tuple or list or tensor, but got {x}.")
 
 
 @constexpr
 def check_is_const_int(x, op_name, arg_name):
     """check whether x is const int."""
     if x is None:
-        raise TypeError(f"For '{op_name}', the '{arg_name}' should be a const int number, but got not const.")
+        raise TypeError(
+            f"For '{op_name}', the '{arg_name}' should be a const int number, but got not const.")
     if not isinstance(x, int):
-        raise TypeError(f"For '{op_name}', the '{arg_name}' should be a const int number, but got {x}.")
+        raise TypeError(
+            f"For '{op_name}', the '{arg_name}' should be a const int number, but got {x}.")
     return True
 
 
-@constexpr
+@_primexpr
 def check_is_tensor_bool_cond(shp):
     """check if tensor is a bool condition"""
-    if shp in ((), (1,)):
+    if not shp or (len(shp) == 1 and shp[0] == 1):
         return True
+    if None in shp:
+        raise ValueError(f"Only tensor which shape is () or (1,) can be converted to bool, but got tensor shape is "
+                         f"None")
     raise ValueError(f"Only tensor which shape is () or (1,) can be converted to bool, but got tensor shape is {shp}")
 
 
 @constexpr
 def const_tensor_to_bool(x):
-    """convert bool tensor to bool condition"""
+    """convert bool tensor to bool condition
+        def const_tensor_to_bool(x):
+        convert bool tensor to bool condition
+        if x.shape == (1,):
+            return bool(x[0])
+        return bool(x)
+    """
     if x is None:
         raise ValueError("Only tensor which shape is () or (1,) can be converted to bool, but got None")
     x = x.asnumpy()
@@ -2533,7 +3273,7 @@ def const_tensor_to_bool(x):
         f"Only tensor which shape is () or (1,) can be converted to bool, but got tensor shape is {x.shape}")
 
 
-@constexpr
+@_primexpr
 def check_view_shape(x):
     """Check view function input shape"""
     if not x:
@@ -2545,32 +3285,27 @@ def check_view_shape(x):
     return x
 
 
-# convert normal param_check functions to constexpr functions
 check_astype_dtype_const = constexpr(validator.check_astype_dtype)
 check_transpose_axis_const = constexpr(validator.check_transpose_axis)
-check_reshape_shp_const = constexpr(validator.check_reshape_shp)
-check_flatten_order_const = constexpr(validator.check_flatten_order)
-check_swapaxes_axis_const = constexpr(validator.check_swapaxes_axis)
-prepare_shape_for_squeeze_const = constexpr(validator.prepare_shape_for_squeeze)
-check_axis_in_range_const = constexpr(validator.check_axis_in_range)
-check_axis_valid = constexpr(validator.check_axis_valid)
 max_ = constexpr(validator.max_)
 min_ = constexpr(validator.min_)
-expanded_shape = constexpr(validator.expanded_shape)
-tuple_slice = constexpr(validator.tuple_slice)
-infer_out_shape = constexpr(validator.infer_out_shape)
-get_log2_size = constexpr(validator.get_log2_size)
-check_axis_type = constexpr(validator.check_axis_type)
-check_and_canonicalize_axes = constexpr(validator.check_and_canonicalize_axes)
-empty_compile = constexpr(validator.empty_compile)
+expanded_shape = validator.expanded_shape
+tuple_slice = validator.tuple_slice
 check_type_support = constexpr(validator.check_type_support)
-check_is_int = constexpr(validator.check_is_int)
 check_type_name = constexpr(validator.check_type_name)
 check_value_type = constexpr(validator.check_value_type)
-check_int = constexpr(validator.check_int)
+check_is_int = constexpr(validator.check_is_int)
+check_bool_type = constexpr(validator.check_bool)
+check_is_int = constexpr(validator.check_is_int)
 check_bool = constexpr(validator.check_bool)
 
 
+@constexpr
+def empty_compile(dtype, shape):
+    """Returns an empty Tensor."""
+    return Tensor_(dtype, shape)
+
+
 def tensor_bool(x):
     """tensor as condition, if is constant, return immediate bool value"""
     is_cond = check_is_tensor_bool_cond(F.shape(x))
@@ -2594,6 +3329,11 @@ def matmul(x, y):
     return F.matmul(x, y)
 
 
+def inner(x, other):
+    """Computes the inner product of 2 tensors."""
+    return F.inner(x, other)
+
+
 def float_bool(x):
     """Implementation of `float_bool`."""
     return x != 0.0
@@ -2618,9 +3358,11 @@ def str_bool(x):
     return True
 
 
-def matrix_determinant(x):
-    """Computes the determinant of one or more square matrices."""
-    return F.matrix_determinant(x)
+def matrix_power(input, n):
+    """
+    Raises a square matrix to the (integer) power `n` .
+    """
+    return F.matrix_power(input, n)
 
 
 def log1p(x):
@@ -2656,9 +3398,9 @@ def logit(x, eps=None):
     return F.logit(x, eps)
 
 
-def log_matrix_determinant(x):
-    """Computes the sign and the log of the absolute value of the determinant of one or more square matrices."""
-    return F.log_matrix_determinant(x)
+def logdet(x):
+    """Returns the log determinant of one or batches of square matrices."""
+    return F.logdet(x)
 
 
 def lerp(start, end, weight):
@@ -2666,9 +3408,10 @@ def lerp(start, end, weight):
     return F.lerp(start, end, weight)
 
 
-def norm(input_x, axis, p=2, keep_dims=False, epsilon=1e-12):
+# pylint: disable=redefined-builtin
+def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
     """Returns the matrix norm or vector norm of a given tensor."""
-    return F.norm(input_x, axis, p, keep_dims, epsilon)
+    return F.norm(A, ord, dim, keepdim, dtype=dtype)
 
 
 def renorm(input_x, p, dim, maxnorm):
@@ -2681,6 +3424,15 @@ def renorm(input_x, p, dim, maxnorm):
     return F.renorm(input_x, p, dim, maxnorm)
 
 
+def sequence_index(sequence, target, start=None, end=None):
+    """Implementation of `tuple_index`."""
+    if start is None:
+        start = 0
+    if end is None:
+        end = len(sequence)
+    return SequenceIndex()(sequence, target, start, end)
+
+
 def list_bool(x):
     """Implementation of `tuple_bool`."""
     return len(x) != 0
@@ -2720,49 +3472,47 @@ def ceil(x):
 
 def top_k(input_x, k, sorted=True):
     """
-    Finds values and indices of the `k` largest entries along the last dimension.
+    `Tensor.top_k` is deprecated, please use `Tensor.topk` instead.
     """
     check_is_int(k, 'k')
     check_bool(sorted, 'sorted')
     return F.top_k(input_x, k, sorted)
 
 
-#############
-# Iteration #
-#############
-
-
-@ms_class
-class SequenceIterator:
+def topk(input_x, k, dim=None, largest=True, sorted=True):
+    r"""
+    For details, please refer to :func:`mindspore.ops.topk`.
     """
-    SequenceIterator is a util class for iterating sequence object.
+    check_is_int(k, 'k')
+    check_bool_type(sorted, 'sorted')
+    return F.topk(input_x, k, dim, largest=largest, sorted=sorted)
 
-    Iterator to use for sequences like List, Array.
-    """
 
-    def __init__(self, idx, seq):
-        self.idx = idx
-        self.seq = seq
+def subtract(x, other, *, alpha=1):
+    r"""
+    Computes the element-wise subtraction of input tensors.
+    """
+    return F.sub(x, other * alpha)
 
-    @core(ignore_values=True)
-    def __ms_hasnext__(self):
-        """Whether the index is past the length of the sequence."""
-        return self.idx < ms_len(self.seq)
 
-    @core(ignore_values=True)
-    def __ms_next__(self):
-        """Return the next element and a new iterator."""
-        return self.seq[self.idx], SequenceIterator(self.idx + 1, self.seq)
+def true_divide(divident, divisor):
+    r"""
+    Computes the element-wise division of input tensors.
+    """
+    return F.div(divident, divisor, rounding_mode=None)
 
 
-def list_iter(xs):
-    """Iterator for List."""
-    return SequenceIterator(0, xs)
+# pylint: disable=redefined-outer-name
+def triu(input, diagonal=0):
+    r"""
+    Returns the triangular matrix based on the diagonal.
+    """
+    return F.triu(input, diagonal)
 
 
-def array_iter(xs):
-    """Iterator for Array."""
-    return SequenceIterator(0, xs)
+#############
+# Iteration #
+#############
 
 
 def tuple_next(xs):
@@ -2785,13 +3535,44 @@ def list_hasnext(xs):
     return len(xs) > 0
 
 
+def dict_next(xs):
+    """Next array."""
+    keys = xs.keys()
+    new_keys = F.make_list()
+    new_values = F.make_list()
+    for i in range(1, len(keys)):
+        new_keys.append(keys[i])
+        new_values.append(xs[keys[i]])
+    new_dict = {}
+    return keys[0], new_dict.fromkeys(new_keys, new_values)
+
+
+def dict_hasnext(xs):
+    """Whether the dict is empty or not."""
+    return len(xs) > 0
+
+
+def array_next(xs):
+    """Next array."""
+    return xs[0], xs[1:]
+
+
+def array_hasnext(xs):
+    """Whether the array is empty or not."""
+    return len(xs) > 0
+
+
 def list_append(self_, list_item):
     """Append into list"""
+    if F.is_sequence_shape_unknown(self_):
+        return ListAppend()(self_, list_item)
     return _append(self_, list_item)
 
 
 def list_insert(self_, index, obj):
     """Insert into list"""
+    if F.is_sequence_shape_unknown(self_) or not F.isconstant(index) or not F.isconstant(obj):
+        return ListInsert()(self_, index, obj)
     return _insert(self_, index, obj)
 
 
@@ -2807,23 +3588,40 @@ def list_clear(self_):
 
 
 def list_reverse(self_):
-    """Reverse the list"""
+    """Reverse the obj in list"""
     return _reverse(self_)
 
 
 def list_extend(self_, obj):
-    """Append another list to the end of the list"""
+    """Append obj to list"""
     return _extend(self_, obj)
 
 
-def list_count(self_, value):
-    """"Count the number of times an element appears in list"""
-    return _count(self_, value)
-
-
 def dict_get(self_, key_index, default_value=None):
     """Get value by key from dict"""
-    return F.dict_getitem(self_, key_index, default_value)
+    if not _haskey(self_, key_index):
+        return default_value
+    return F.dict_getitem(self_, key_index)
+
+
+def dict_clear(self_):
+    """Clear the dict"""
+    return _dict_clear(self_)
+
+
+def dict_haskey(self_, key_index):
+    """Check if key is in dict"""
+    return _haskey(self_, key_index)
+
+
+def dict_update(self_, dict_obj):
+    """Update the dict"""
+    return _update(self_, dict_obj)
+
+
+def dict_fromkeys(self_, seq, value=None):
+    """Check if key is in dict"""
+    return _fromkeys(self_, seq, value)
 
 
 #################
@@ -2831,11 +3629,6 @@ def dict_get(self_, key_index, default_value=None):
 #################
 
 
-def to_array(x):
-    """Implementation of `to_array`."""
-    return x.__ms_to_array__()
-
-
 def filter_(fun, iter_):
     """Support the use of built-in function filter."""
     result = []
@@ -2882,9 +3675,11 @@ def csr_mv(x, dense_vector):
     return F.csr_mv(x, dense_vector)
 
 
-def csr_mm(x, dense):
+def csr_mm(x, matrix):
     """Implementation of `mm` for CSRTensor."""
-    return _csr_mm(x.indptr, x.indices, x.values, x.shape, dense)
+    if isinstance(matrix, CSRTensor):
+        return F.csr_mm(x, matrix)
+    return _csr_mm(x.indptr, x.indices, x.values, x.shape, matrix)
 
 
 def csr_to_tuple(x):
@@ -2912,7 +3707,7 @@ def coo_abs(x):
 
 def coo_add(x, y, thresh):
     """Implementation of `add` for COOTensor."""
-    return sparse_add(x, y, thresh)
+    return F.coo_add(x, y, thresh)
 
 
 ################
@@ -2934,12 +3729,12 @@ def sparse_ndim_(x):
     return F.tuple_len(x.shape)
 
 
-def bernoulli(x, p=0.5, seed=-1):
+def bernoulli(input, p=0.5, seed=None):
     """
     Randomly draws binary numbers from a Bernoulli distribution.
     """
     check_is_int(seed, 'bernoulli', 'seed')
-    return F.bernoulli(x, p, seed)
+    return F.bernoulli(input, p, seed)
 
 
 def gather_nd(input_x, indices):
@@ -2950,20 +3745,53 @@ def gather_nd(input_x, indices):
     return F.gather_nd(input_x, indices)
 
 
-def gather(input_x, input_indices, axis):
+def gather(input_x, input_indices, axis, batch_dims=0):
     r"""
     Returns the slice of the input tensor corresponding to the elements of `input_indices` on the specified `axis`.
     Refer to :func:`mindspore.ops.gather` for more detail.
     """
-    return F.gather(input_x, input_indices, axis)
+    return F.gather(input_x, input_indices, axis, batch_dims)
 
 
-def split(input_x, axis=0, output_num=1):
+def split(tensor, split_size_or_sections, axis=0):
     """
-    Splits the input tensor into output_num of tensors along the given axis and output numbers.
+    Splits the Tensor into chunks along the given axis.
     Refer to :func:`mindspore.ops.split` for more detail.
     """
-    return F.split(input_x, axis, output_num)
+    return F.split(tensor, split_size_or_sections, axis)
+
+
+def tensor_split(input, indices_or_sections, axis=0):
+    """
+    Splits a tensor into multiple sub-tensors along the given axis.
+    Refer to :func:`mindspore.ops.tensor_split` for more detail.
+    """
+    return F.tensor_split(input, indices_or_sections, axis=axis)
+
+
+def vsplit(input, indices_or_sections):
+    """
+    Splits a tensor into multiple sub-tensors vertically. It is equivalent to `ops.tensor_split` with :math:`axis=0` .
+    Refer to :func:`mindspore.ops.vsplit` for more detail.
+    """
+    return F.vsplit(input, indices_or_sections)
+
+
+def hsplit(input, indices_or_sections):
+    """
+    Splits a tensor into multiple sub-tensors horizontally. It is equivalent to `ops.tensor_split` with :math:`axis=1` .
+    Refer to :func:`mindspore.ops.hsplit` for more detail.
+    """
+    return F.hsplit(input, indices_or_sections)
+
+
+def dsplit(input, indices_or_sections):
+    """
+    Splits a tensor into multiple sub-tensors along the 3rd axis.
+    It is equivalent to `ops.tensor_split` with :math:`axis=2` .
+    Refer to :func:`mindspore.ops.tensor_split` for more detail.
+    """
+    return F.dsplit(input, indices_or_sections)
 
 
 def xlogy(x, y):
@@ -2998,6 +3826,20 @@ def isfinite(x):
     return F.isfinite(x)
 
 
+def sin(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.sin`.
+    """
+    return F.sin(x)
+
+
+def sinc(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.sinc`.
+    """
+    return F.sinc(x)
+
+
 def cos(x):
     r"""
     Computes cosine of input element-wise.
@@ -3005,6 +3847,13 @@ def cos(x):
     return F.cos(x)
 
 
+def cov(x, *, correction=1, fweights=None, aweights=None):
+    r"""
+    For details, please refer to :func:`mindspore.ops.cov`.
+    """
+    return F.cov(x, correction=correction, fweights=fweights, aweights=aweights)
+
+
 def acos(x):
     r"""
     Computes arccosine of input tensors element-wise.
@@ -3019,32 +3868,53 @@ def asin(x):
     return F.asin(x)
 
 
-def acosh(x):
+def acosh(input):
     r"""
     Computes inverse hyperbolic cosine of the inputs element-wise.
     """
-    return F.acosh(x)
+    return F.acosh(input)
 
 
-def add(x, y):
+def add(input, other):
     r"""
     Computes the element-wise addition of input tensors.
     """
-    return F.add(x, y)
+    return F.add(input, other)
 
 
 def addr(x, vec1, vec2, beta=1, alpha=1):
     r"""
     Computes the outer-product of `vec1` and `vec2` and adds it to `x`.
     """
-    return F.addr(x, vec1, vec2, beta=1, alpha=1)
+    return F.addr(x, vec1, vec2, beta=beta, alpha=alpha)
+
+
+def addbmm(x, batch1, batch2, *, beta=1, alpha=1):
+    r"""
+    Performs matrix multiplication with a reduced sum, and add `x` to the result.
+    """
+    return F.addbmm(x, batch1, batch2, beta=beta, alpha=alpha)
+
+
+def addmm(x, mat1, mat2, *, beta=1, alpha=1):
+    r"""
+    Performs matrix multiplication, and add `x` to the result.
+    """
+    return F.addmm(x, mat1, mat2, beta=beta, alpha=alpha)
 
 
 def addmv(x, mat, vec, beta=1, alpha=1):
     r"""
     Multiplies matrix `mat` and vector `vec`. The vector `x` is added to the final result.
     """
-    return F.addmv(x, mat, vec, beta, alpha)
+    return F.addmv(x, mat, vec, beta=beta, alpha=alpha)
+
+
+def adjoint(x):
+    r"""
+    Computes the conjucated matrix with the last 2 dimensions transposed.
+    """
+    return F.adjoint(x)
 
 
 def asinh(x):
@@ -3054,11 +3924,11 @@ def asinh(x):
     return F.asinh(x)
 
 
-def atan(x):
+def atan(input):
     r"""
     Computes inverse tangent of the input element-wise.
     """
-    return F.atan(x)
+    return F.atan(input)
 
 
 def atanh(x):
@@ -3068,9 +3938,16 @@ def atanh(x):
     return F.atanh(x)
 
 
+def baddbmm(x, batch1, batch2, beta=1, alpha=1):
+    r"""
+    For details, please refer to :func:`mindspore.ops.baddbmm`.
+    """
+    return F.baddbmm(x, batch1, batch2, beta=beta, alpha=alpha)
+
+
 def bmm(input_x, mat2):
     r"""
-    Computes  matrix multiplication between two tensors by batch.
+    Computes matrix multiplication between two tensors by batch.
     """
     return F.bmm(input_x, mat2)
 
@@ -3080,3 +3957,471 @@ def value_(x):
     Get the value of Parameter or Tensor x. If x is Parameter, will change the type from RefTensor to Tensor.
     """
     return P.Load()(x, monad.U)
+
+
+def to(input_x, dtype):
+    r"""
+    Performs tensor dtype conversion.
+    """
+    return P.Cast()(input_x, dtype)
+
+
+def to_bool(input_x):
+    r"""
+    Converts input tensor dtype to bool.
+    """
+    return P.Cast()(input_x, mstype.bool_)
+
+
+def to_float(input_x):
+    r"""
+    Converts input tensor dtype to float32.
+    """
+    return P.Cast()(input_x, mstype.float32)
+
+
+def to_half(input_x):
+    r"""
+    Converts input tensor dtype to float16.
+    """
+    return P.Cast()(input_x, mstype.float16)
+
+
+def to_int(input_x):
+    r"""
+    Converts input tensor dtype to int32.
+    """
+    return P.Cast()(input_x, mstype.int32)
+
+
+def to_long(input_x):
+    r"""
+    Converts input tensor dtype to int64.
+    """
+    return P.Cast()(input_x, mstype.int64)
+
+
+def cholesky(input_x, upper=False):
+    r"""
+    Computes the Cholesky decomposition of a symmetric positive-definite matrix
+    """
+    return F.cholesky(input_x, upper=upper)
+
+
+def cholesky_inverse(input_x, upper=False):
+    r"""
+    Computes the inverse of the positive definite matrix using cholesky matrix factorization.
+    """
+    return F.cholesky_inverse(input_x, upper=upper)
+
+
+def map_tensor_get(map_tensor, key_tensor, insert_default_value=True):
+    r"""
+    Get or create value according the key tensor from a map tensor.
+    """
+    return _map_tensor_ops.MapTensorGet(insert_default_value)(map_tensor, key_tensor)
+
+
+def map_tensor_put(map_tensor, key_tensor, value_tensor):
+    r"""
+    Insert or update key value tensor pairs to a map tensor.
+    """
+    return _map_tensor_ops.put(map_tensor, key_tensor, value_tensor)
+
+
+def map_tensor_erase(map_tensor, key_tensor):
+    r"""
+    Remove records according the key tensor from a map tensor.
+    """
+    return _map_tensor_ops.erase(map_tensor, key_tensor)
+
+
+def map_tensor_get_keys(map_tensor):
+    r"""
+    Get all keys as a tensor.
+    """
+    return _map_tensor_ops.get_keys(map_tensor)
+
+
+def map_tensor_get_values(map_tensor):
+    r"""
+    Get all values as a tensor.
+    """
+    return _map_tensor_ops.get_values(map_tensor)
+
+
+def map_tensor_get_data(map_tensor):
+    r"""
+    Get all keys and values as a tensor.
+    """
+    return _map_tensor_ops.get_data(map_tensor)
+
+
+def conj(input):
+    r"""
+    Computes complex conjugate of the input element-wise.
+    """
+    return F.conj(input)
+
+
+def cross(input, other, dim=None):
+    r"""
+    Computes the cross product of input vectors in specified dimension.
+    """
+    return F.cross(input, other, dim)
+
+
+def erfinv(input):
+    r"""
+    Computes the inverse error function of input tensor.
+    """
+    return F.erfinv(input)
+
+
+def less_equal(input, other):
+    r"""
+    Computes the boolean value of :math:`input\_x <= other` element-wise.
+    """
+    return F.less_equal(input, other)
+
+
+def lcm(x, other):
+    r"""
+    Computes least common multiplier of input tensors element-wise.
+    """
+    return F.lcm(x, other)
+
+
+def ldexp(x, other):
+    r"""
+    Multiplies input by 2**:attr:other.
+    """
+    return F.ldexp(x, other)
+
+
+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.
+    """
+    return F.fold(input, output_size, kernel_size, dilation, padding, stride)
+
+
+def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
+    r"""
+    Extracts sliding local blocks from a batched input tensor.
+    """
+    return F.unfold(input, kernel_size, dilation, padding, stride)
+
+
+def expand(input, size):
+    r"""
+    Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
+    """
+    return F.expand(input, size)
+
+
+def cumprod(input, dim, dtype=None):
+    r"""
+    Computes the cumulative product of the `input` tensor along dimension `dim`.
+    """
+    return F.cumprod(input, dim, dtype)
+
+
+def multiply(input, other):
+    """For details, please refer to :func:`mindspore.ops.multiply`."""
+    return F.multiply(input, other)
+
+
+def div(input, value, *, rounding_mode=None):
+    r"""
+    Divides the tensor `input` by the given input tensor `value` in floating-point type element-wise.
+    """
+    return F.div(input, value, rounding_mode=rounding_mode)
+
+
+def equal(x, y):
+    r"""
+    Computes the equivalence between the tensor `x` and the given input tensor `y` element-wise.
+    """
+    return F.equal(x, y)
+
+
+def expm1(input_x):
+    r"""
+    Computes exponential then minus 1 of a tensor element-wise.
+    """
+    return F.expm1(input_x)
+
+
+@constexpr
+def _check_index_add_alpha(alpha):
+    check_is_number(alpha, (int, float))
+
+
+def index_add(input, dim, index, source, *, alpha=1):
+    r"""
+    Adds tensor `alpha` times `source`  to specified `dim` and `index` of input tensor.
+    """
+    _check_index_add_alpha(alpha)
+    source = source * alpha
+    return F.index_add(input, indices=index, y=source, axis=dim)
+
+
+def greater(input, other):
+    r"""
+    Computes the boolean value of :math:`input > other` element-wise.
+    """
+    return F.greater(input, other)
+
+
+def greater_equal(input, other):
+    r"""
+    Computes the boolean value of :math:`input >= other` element-wise.
+    """
+    return F.greater_equal(input, other)
+
+
+def igamma(input, other):
+    r"""
+    Computes lower regularized incomplete Gamma function.
+    """
+    return F.igamma(input, other)
+
+
+def igammac(input, other):
+    r"""
+    Computes upper regularized incomplete Gamma function.
+    """
+    return F.igammac(input, other)
+
+
+def isinf(input):
+    r"""
+    Determines which elements are inf or -inf for each position.
+    """
+    return F.isinf(input)
+
+
+def isnan(input):
+    r"""
+    Determines which elements are NaN for each position.
+    """
+    return F.isnan(input)
+
+
+def le(input, other):
+    r"""
+    Computes the boolean value of :math:`input <= other` element-wise.
+    """
+    return F.le(input, other)
+
+
+def less(input, other):
+    r"""
+    Computes the boolean value of :math:`input < other` element-wise.
+    """
+    return F.less(input, other)
+
+
+def logical_and(input, other):
+    r"""
+    Computes the "logical AND" of two tensors element-wise.
+    """
+    return F.logical_and(input, other)
+
+
+def logical_not(input):
+    r"""
+    Computes the "logical NOT" of input tensor element-wise.
+    """
+    return F.logical_not(input)
+
+
+def logical_or(input, other):
+    r"""
+    Computes the "logical OR" of two tensors element-wise.
+    """
+    return F.logical_or(input, other)
+
+
+def logical_xor(input, other):
+    r"""
+    Computes the "logical XOR" of two tensors element-wise.
+    """
+    return F.logical_xor(input, other)
+
+
+def lstsq(input, A):
+    r"""
+    Computes the solutions of the least squares and minimum norm problems of full-rank
+    matrix `input` of size :math:`(m \times n)` and matrix `A` of size :math:`(m \times k)`.
+    """
+    return F.lstsq(input, A)
+
+
+def mvlgamma(input, p):
+    r"""
+    Computes the multivariate log-gamma function with dimension p element-wise.
+    """
+    return F.mvlgamma(input, p)
+
+
+def maximum(input, other):
+    r"""
+    Computes the maximum of input tensors element-wise.
+    """
+    return F.maximum(input, other)
+
+
+def mul(input, other):
+    r"""
+    Multiplies two tensors element-wise.
+    """
+    return F.mul(input, other)
+
+
+def neg(input):
+    r"""
+    Returns a tensor with negative values of the input tensor element-wise.
+    """
+    return F.neg(input)
+
+
+def ne(input, other):
+    r"""
+    Computes the non-equivalence of two tensors element-wise.
+    """
+    return F.ne(input, other)
+
+
+def not_equal(x, other):
+    r"""
+    Computes the non-equivalence of two tensors element-wise.
+    """
+    return F.not_equal(x, other)
+
+
+def sign(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.sign`.
+    """
+    return F.sign(x)
+
+
+def signbit(x):
+    """
+    For details, please refer to :func:`mindspore.ops.signbit`.
+    """
+    return F.signbit(x)
+
+
+def sgn(x):
+    """
+    For details, please refer to :func:`mindspore.ops.sgn`.
+    """
+    return F.sgn(x)
+
+
+def sinh(input):
+    r"""
+    Computes hyperbolic sine of the input element-wise.
+    """
+    return F.sinh(input)
+
+
+def sort(input, axis=-1, descending=False):
+    r"""
+    Sorts the elements of the input tensor along a given dimension in ascending order by value.
+    """
+    return F.sort(input, axis=axis, descending=descending)
+
+
+def argsort(input, axis=-1, descending=False):
+    """For details, please refer to :func:`mindspore.ops.argsort`."""
+    return F.argsort(input, axis, descending)
+
+
+def trunc(input):
+    r"""
+    Returns a new tensor with the truncated integer values of the elements of input.
+    """
+    return F.trunc(input)
+
+
+def where(x, condition, y):
+    r"""
+    Returns a tensor whose elements are selected from either `x` or `y` depending on `condition`.
+    Please refer to :func:`mindspore.ops.where`.
+    """
+    return F.where(condition, x, y)
+
+
+def imag(input):
+    r"""
+    Returns a new tensor containing imaginary value of the input.
+    """
+    return F.imag(input)
+
+
+def diff(x, n=1, axis=-1, prepend=None, append=None):
+    r"""
+    For details, please refer to :func:`mindspore.ops.diff`.
+    """
+    return F.diff(x, n, axis, prepend, append)
+
+
+def frac(x):
+    r"""
+    For details, please refer to :func:`mindspore.ops.frac`.
+    """
+    return F.frac(x)
+
+
+def argwhere(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.argwhere`.
+    """
+    return F.argwhere(input)
+
+
+def moveaxis(input, source, destination):
+    r"""
+    For details, please refer to :func:`mindspore.ops.moveaxis`.
+    """
+    return F.moveaxis(input, source, destination)
+
+
+def movedim(input, source, destination):
+    r"""
+    For details, please refer to :func:`mindspore.ops.movedim`.
+    """
+    return F.movedim(input, source, destination)
+
+
+def nextafter(input, other):
+    r"""
+    For details, please refer to :func:`mindspore.ops.nextafter`.
+    """
+    return F.nextafter(input, other)
+
+
+def qr(input, some=True):
+    r"""
+    For details, please refer to :func:`mindspore.ops.qr`.
+    """
+    check_bool_type(some, 'some', 'Tensor.qr')
+    return F.qr(input, 'reduced' if some else 'complete')
+
+
+def amax(input, axis=None, keep_dims=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.amax`.
+    """
+    return F.amax(input, axis, keep_dims)
+
+
+def amin(input, axis=None, keep_dims=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.amin`.
+    """
+    return F.amin(input, axis, keep_dims)