mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/_extends/parse/standard_method.py

@@ -24,20 +24,21 @@ 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
+    _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 
 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 ..._checkparam import check_is_number, check_reshape_shp, 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 import composite
-from ...ops.composite import tail, MultitypeFuncGraph, env_get, hyper_add, \
+from ...ops.operations import array_ops
+from ...ops.composite import 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, issubclass_
+from ...ops.operations._inner_ops import Format
 from ...ops.operations import _csr_ops
 from ...ops.operations import _map_tensor_ops
 from ...ops.primitive import constexpr, _primexpr
@@ -57,7 +58,6 @@ size_op_ = P.Size()
 _format = Format()
 _reduce_sum_default = P.ReduceSum()
 _reduce_sum_keepdims = P.ReduceSum(True)
-_mean_keepdims = P.ReduceMean(True)
 _csr_mm = _csr_ops.CSRMM()
 
 itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
@@ -91,10 +91,7 @@ def mean(x, axis=None, keep_dims=False):
         >>> print(output)
         2.0
     """
-    if axis is None:
-        axis = ()
-    reduce_mean = P.ReduceMean(keep_dims)
-    return reduce_mean(x, axis)
+    return F.mean(x, axis, keep_dims)
 
 
 def ndimension(x):
@@ -109,7 +106,7 @@ def prod(input, axis=None, keep_dims=False):
     Args:
         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: None.
+            when axis is None or empty tuple, reduce all dimensions. Default: ``None``.
         keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
 
     Returns:
@@ -175,11 +172,7 @@ def all_(x, axis=(), keep_dims=False):
     Returns:
         Tensor, has the same data type as x.
     """
-
-    if axis is None:
-        axis = ()
-    reduce_all = P.ReduceAll(keep_dims)
-    return reduce_all(x, axis)
+    return F.all(x, axis, keep_dims)
 
 
 def angle(x):
@@ -314,6 +307,52 @@ def slogdet(x):
     return F.slogdet(x)
 
 
+def cauchy(x, median=0.0, sigma=1.0):
+    r"""
+    Fills the tensor with numbers drawn from the Cauchy distribution. It is
+    defined as follows:
+
+    .. math::
+        f(x)= \frac{1}{\pi} \frac{\sigma}{(x-median)^2 +\sigma^2}
+
+    Args:
+        x (Tensor): Input tensor.
+        median (float, optional): the location parameter, specifying the location
+            of the peak of the distribution. Default: 0.0.
+        sigma (float, optional): the scale parameter which specifies the half-width
+            at half-maximum. Default: 1.0.
+
+    Returns:
+        Tensor. A Tensor with the same type and shape of input.
+    """
+    out = P.Cauchy(list(x.shape), median, sigma)()
+    return F.cast(out, x.dtype)
+
+
+def log_normal(x, mean=1.0, std=2.0):
+    r"""
+    Fills the elements of the input tensor with log normal values initialized by
+    given mean and std:
+
+    .. math::
+        \text{f}(x;1.0,2.0)=\frac{1}{x\delta \sqrt[]{2\pi} }e^{-\frac{(\ln x-\mu )^2}{2\delta ^2} }
+
+    where \mu, \delta is mean and standard deviation of log normal distribution respectively.
+
+    Args:
+        x (Tensor): Input tensor.
+        mean (float, optional): the mean of normal distribution. With float data type.
+            Default: 1.0.
+        std (float, optional): the std of normal distribution. With float data type.
+            Default: 2.0.
+
+    Returns:
+        Tensor. A Tensor with the same type and shape of input.
+    """
+    log_normal = P.LogNormalReverse(mean, std)
+    return log_normal(x)
+
+
 def chunk(x, chunks, axis=0):
     r"""
     For details, please refer to :func:`mindspore.ops.chunk`.
@@ -340,7 +379,7 @@ def hasattr(x, attr):  # pylint: disable=redefined-builtin
         Boolean value, indicates whether the object x has attribute attr.
     """
     out = getattr(x, attr, mstype._null)
-    return not isinstance(out, mstype._null_type)
+    return not isinstance(out, mstype._NullType)
 
 
 def astype(x, dtype, copy=True):  # pylint: disable=redefined-outer-name
@@ -397,25 +436,25 @@ def multinomial(input, num_samples, replacement=True, seed=None):
     return F.multinomial(input, num_samples, replacement, seed)
 
 
-def tile(x, multiples):
+def tile(x, reps):
     r"""
-    Replicates an input tensor with given multiples times.
+    Replicates an input tensor with given reps 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.
+    Creates a new tensor by replicating `input_x` `reps` times. The i'th dimension of
+    output tensor has `input_x.shape[i] * reps[i]` elements, and the values of `input_x`
+    are replicated `reps[i]` times along the i'th dimension.
 
     Note:
-        The length of `multiples` must be greater or equal to the length of dimension in `input_x`.
+        The length of `reps` 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,
+        reps (tuple[int]): The parameter that specifies the number of replications,
             the parameter type is tuple, and the data type is int, i.e., :math:`(y_1, y_2, ..., y_S)`.
-            The length of `multiples` cannot be smaller than the length of the shape of `input_x`.
+            The length of `reps` 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`,
+        Tensor, has the same data type as the `input_x`. Suppose the length of `reps` 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
@@ -426,9 +465,9 @@ def tile(x, multiples):
           :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`.
+        TypeError: If `reps` is not a tuple or its elements are not all int.
+        ValueError: If the elements of `reps` are not all greater than 0.
+        ValueError: If the length of `reps` are smaller than the length of dimension in `input_x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -437,15 +476,15 @@ def tile(x, multiples):
         >>> 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)
+        >>> reps = (2, 3)
+        >>> output = input_x.tile(reps)
         >>> 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)
+        >>> reps = (2, 3, 2)
+        >>> output = input_x.tile(reps)
         >>> print(output)
         [[[1. 2. 1. 2.]
         [3. 4. 3. 4.]
@@ -460,7 +499,7 @@ def tile(x, multiples):
         [1. 2. 1. 2.]
         [3. 4. 3. 4.]]]
     """
-    return F.tile(x, multiples)
+    return F.tile(x, reps)
 
 
 def short(x):
@@ -506,7 +545,7 @@ def transpose(x, *axis):
         (3, 2, 1)
     """
     ndim = F.rank(x)
-    perm = check_transpose_axis_const(axis, ndim)
+    perm = validator.check_transpose_axis(axis, ndim)
     return F.transpose(x, perm)
 
 
@@ -716,6 +755,20 @@ def scatter(self, axis, index, src):
     return F.scatter(self, axis, index, src)
 
 
+def slice_scatter(input, src, axis=0, start=None, end=None, step=1):
+    r"""
+    Embeds the src into the input Tensor according to `axis`.
+    """
+    return F.slice_scatter(input, src, axis, start, end, step)
+
+
+def select_scatter(input, src, axis, index):
+    r"""
+    On the specified dimension `axis` of `input` , `src` is scattered into `input` on the specified `index` of `input` .
+    """
+    return F.select_scatter(input, src, axis, index)
+
+
 def swapaxes(input, axis0, axis1):
     """
     Interchange two axes of a tensor.
@@ -755,12 +808,7 @@ def squeeze(x, axis=None):
         >>> print(x.shape)
         (2, 2)
     """
-    shape = F.shape(x)
-    if axis is None:
-        return F.squeeze(x)
-    # yield squeezed shape based on the axes
-    new_shape = prepare_shape_for_squeeze(shape, axis)
-    return F.reshape(x, new_shape)
+    return F.squeeze(x, axis)
 
 
 def unbind(input, dim=0):
@@ -775,7 +823,7 @@ def argmax(x, axis=None, keepdims=False):
     Args:
         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.
+          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.
 
@@ -795,15 +843,7 @@ def argmax(x, axis=None, keepdims=False):
         >>> print(a.argmax())
         5
     """
-    is_axis_none = False
-    if axis is None:
-        x = ravel(x)
-        axis = 0
-        is_axis_none = True
-    out = P.Argmax(axis, mstype.int64)(x)
-    if keepdims and not is_axis_none:
-        out = expand_dims(out, axis)
-    return out
+    return F.argmax(x, axis, keepdims)
 
 
 def argmin(x, axis=None, keepdims=False):
@@ -1169,6 +1209,13 @@ def logaddexp2(input, other):
     return F.logaddexp2(input, other)
 
 
+def logcumsumexp(input, axis):
+    """
+    Computes the logarithm of the sum of exponentiations of the inputs along specified dimension.
+    """
+    return F.logcumsumexp(input, axis)
+
+
 def logsumexp(input, axis, keepdims=False):
     """
     Reduces a dimension of a tensor by calculating exponential for all elements in the dimension,
@@ -1239,7 +1286,7 @@ 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)
+    perm = validator.check_transpose_axis(axis, ndim)
     return F.permute(input, perm)
 
 
@@ -1373,8 +1420,9 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
 
     e = F.eye(n, m, dtype)
     if offset >= m or offset <= -n:
-        e = F.fill(dtype, (n, m), 0)
-    elif offset != 0:
+        zero_shape = shape[:-2] + (0,)
+        return F.zeros(zero_shape, dtype)
+    if offset != 0:
         e = e.astype(mstype.float32)
         if offset > 0:
             e_left = F.fill(dtype, (n, offset), 0)
@@ -1404,6 +1452,13 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
     return res.astype(dtype)
 
 
+def diagonal_scatter(input, src, offset, dim1=0, dim2=1):
+    r"""
+    Embed `src` into the diagonal of `input` according to the `dim1` and `dim2`.
+    """
+    return F.diagonal_scatter(input, src, offset, dim1, dim2)
+
+
 def digamma(input):
     """
     Computes the logarithmic derivative of the gamma function on input.
@@ -1481,6 +1536,20 @@ def float_power(x, exponent):
     return F.float_power(x, exponent)
 
 
+def fmax(input, other):
+    """
+    For details, please refer to :func:`mindspore.ops.fmax`.
+    """
+    return F.fmax(input, other)
+
+
+def fmin(input, other):
+    """
+    For details, please refer to :func:`mindspore.ops.fmin`.
+    """
+    return F.fmin(input, other)
+
+
 def fmod(x, other):
     """
     For details, please refer to :func:`mindspore.ops.fmod`.
@@ -1639,6 +1708,22 @@ def take(x, indices, axis=None, mode='clip'):
     return res.reshape(shape_out)
 
 
+def ms_type(input, dtype=None):
+    r"""
+    Change the dtype of the Tensor to the `dtype` . Return the type if `dtype` is None.
+    """
+    if dtype is None:
+        return str(input.dtype)
+    return input.astype(dtype)
+
+
+def type_as(input, other):
+    r"""
+    Change the dtype of `input` to the dtype of `other`.
+    """
+    return input.astype(other.dtype)
+
+
 def _infer_out_shape(*shapes):
     """
     Returns shape of output after broadcasting. Raises ValueError if shapes cannot be broadcast.
@@ -1646,8 +1731,8 @@ def _infer_out_shape(*shapes):
     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]
+        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)
@@ -1758,12 +1843,14 @@ 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))
+        log2_res = F.log2(F.cast(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)
@@ -1801,8 +1888,6 @@ def fill(x, value):
             const_utils.raise_type_error("If None is used as value, the original Tensor's dtype must be float.")
         value = nan_tensor
         return F.tile(value, x.shape).astype(x.dtype)
-    if not isinstance(value, (int, float, bool)):
-        const_utils.raise_type_error("input value must be a scalar.")
     return F.fill(x.dtype, x.shape, value)
 
 
@@ -1813,6 +1898,15 @@ def fills(x, value):
     return F.fills(x, value)
 
 
+def fill_diagonal(x, fill_value, wrap=False):
+    """
+    Fills the main diagonal of a Tensor with a specified value and returns the result. The input has at least
+    2 dimensions, and all dimensions of input must be equal in length when the dimension of input is greater than 2.
+    """
+
+    return P.FillDiagonal(fill_value, wrap)(x)
+
+
 def ptp(x, axis=None, keepdims=False):
     """
     The name of the function comes from the acronym for "peak to peak".
@@ -1823,7 +1917,7 @@ def ptp(x, axis=None, keepdims=False):
     Args:
         x (Tensor): Input tensor.
         axis (Union[None, int, tuple(int)]): Axis or axes along which the range is computed.
-            The default is to compute the variance of the flattened array. Default: None.
+            The default is to compute the variance of the flattened array. Default: ``None``.
         keepdims (bool): Default is False.
 
     Returns:
@@ -1909,7 +2003,7 @@ def var(x, axis=None, ddof=0, keepdims=False):
         axis = ()
     else:
         axis = check_and_canonicalize_axes(axis, x.ndim)
-    x_mean = _mean_keepdims(x, axis)
+    x_mean = F.mean(x, axis, True)
     x_sub = F.tensor_sub(x, x_mean)
     x_pow = F.tensor_pow(x_sub, 2)
     if keepdims:
@@ -1982,7 +2076,7 @@ def sum(input, axis=None, dtype=None, keepdims=False, initial=None):  # pylint:
 
     Args:
         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.
+        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.
             If axis is a tuple of ints, a sum is performed on all of the axes specified in the tuple
@@ -2017,27 +2111,34 @@ def sum(input, axis=None, dtype=None, keepdims=False, initial=None):  # pylint:
         >>> print(input_x.sum(axis=1))
         [10. 35.]
     """
-    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):
-        const_utils.raise_type_error("integer argument expected")
     if initial is not None and not isinstance(initial, (int, float, bool)):
-        const_utils.raise_type_error("initial argument should be a scalar.")
-    if axis is None:
-        axis = ()
-    else:
-        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 keepdims:
-        res = _reduce_sum_keepdims(input_x, axis)
-    else:
-        res = _reduce_sum_default(input_x, axis)
+        raise TypeError(f"For Tensor.sum, initial must be int, float or bool, but got {type(initial)}.")
+    res = F.sum(input, axis, keepdims)
     if initial is not None:
         res += initial
-    return res.astype(dtype)
+    if dtype is not None:
+        res = res.astype(dtype)
+    return res
+
+
+@_primexpr
+def _check_sum_to_size(size, input_dim, shape_input):
+    """Check the length of size of sum_to_size."""
+    if len(size) > input_dim:
+        raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_input}.")
+
+
+@_primexpr
+def _count_axes(size, input_shape, shape_input):
+    """Count the sum axes for sum_to_size."""
+    axes = []
+    for i in range(len(size)):
+        element = size[i]
+        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}.")
+    return axes
 
 
 def sum_to_size(input, *size):
@@ -2047,17 +2148,12 @@ def sum_to_size(input, *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}.")
+    _check_sum_to_size(size, input.ndim, 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}.")
+
+    axes = _count_axes(size, input.shape, shape_input)
     if axes:
         return input.sum(tuple(axes), keepdims=True)
     return input
@@ -2070,6 +2166,21 @@ def nansum(input, axis=None, keepdims=False, *, dtype=None):
     return F.nansum(input, axis=axis, keepdims=keepdims, dtype=dtype)
 
 
+def nanmean(input, axis=None, keepdims=False, *, dtype=None):
+    r"""
+    Computes the mean of input tensor, ignoring NaN.
+    """
+    return F.nanmean(input, axis, keepdims, dtype=dtype)
+
+
+def nanmedian(input, axis=-1, keepdims=False):
+    r"""
+    Computes the median and indices of input tensor, ignoring NaN.
+    If all elements in the specified dimensions are NaN, the result will be NaN.
+    """
+    return F.nanmedian(input, axis, keepdims)
+
+
 def repeat(x, repeats, axis=None):
     """
     Repeat elements of an array.
@@ -2233,7 +2344,7 @@ def itemset(data, *args):
 
 def ms_iter(xs):
     """Implementation of `iter`."""
-    return xs.__ms_iter__()
+    return xs.__ms_iter__
 
 
 def ms_next(it):
@@ -2246,47 +2357,6 @@ def hasnext(it):
     return it.__ms_hasnext__()
 
 
-@constexpr
-def constant_abs(x):
-    """Returns the absolute value of the constant."""
-    if x is None:
-        raise ValueError("For abs(), the input should be a constant or Tensor type.")
-    return abs(x)
-
-
-def ms_abs(x):
-    """Implementation of `abs`."""
-    if isinstance(x, Tensor):
-        return abs_(x)
-    return constant_abs(x)
-
-
-@constexpr
-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.")
-    return round(*data)
-
-
-def ms_round(*data):
-    """Implementation of `round`."""
-    len_data = len(data)
-    if len_data <= 0 or len_data > 2:
-        const_utils.raise_type_error("round() requires 1 or 2 arguments.")
-    if len_data == 1 or data[1] is None:
-        x = data[0]
-        if isinstance(x, Tensor):
-            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.")
-    return constant_round(*data)
-
-
 @constexpr
 def cast_to_str(data):
     return str(data)
@@ -2300,13 +2370,9 @@ def str_func(*data):
     if data_len == 0:
         return ''
     data = data[0]
-    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.")
-    return cast_to_str(data)
+    if F.isconstant(data):
+        return cast_to_str(data)
+    return data.__str__()
 
 
 @constexpr
@@ -2322,22 +2388,20 @@ def bool_func(*data):
     if data_len == 0:
         return False
     data = data[0]
-    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 more than one element is ambiguous.")
+            return F.scalar_cast(data, mstype.bool_)
+        raise ValueError("The truth value of an array with more than one element is ambiguous.")
     if not F.isconstant(data):
         if hasattr(data, "__bool__"):
             return data.__bool__()
         if hasattr(data, "__len__"):
             return len(data) != 0
-        return True
+        return F.scalar_cast(data, mstype.bool_)
+    if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
+        raise TypeError("bool() does not support sparse tensor input.")
     return cast_to_bool(data)
 
 
@@ -2362,11 +2426,10 @@ def int_func(*data):
     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 base != 10:
+            const_utils.raise_type_error("int() does not support non-constant input when 'base' is specified.")
+        return F.scalar_cast(target, mstype.int64)
     if isinstance(target, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "int() does not support sparse tensor input.")
@@ -2388,11 +2451,8 @@ 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.")
+        return F.scalar_cast(data, mstype.float32)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "float() does not support sparse tensor input.")
@@ -2431,17 +2491,15 @@ def tuple_func(*data):
     """Implementation of `tuple`."""
     data_len = len(data)
     if data_len >= 2:
-        const_utils.raise_type_error("tuple() requires 0 or 1 arguments.")
+        raise TypeError("tuple() requires 0 or 1 arguments.")
     if data_len == 0:
         return F.make_tuple()
     data = data[0]
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
-        const_utils.raise_type_error(
-            "tuple() does not support single sparse tensor input.")
+        raise TypeError("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.")
+        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
     if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
@@ -2704,52 +2762,23 @@ def ms_sum(*data):
     return result
 
 
-@constexpr
-def python_len(data):
-    """Return the result of python built-in len function"""
-    return len(data)
-
-
 def ms_len(data):
     """Implementation of `len`."""
-    if not isinstance(data, Tensor) and F.isconstant(data):
-        return python_len(data)
-    return data.__len__()
-
-
-@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 floor(x):
     """Rounds a tensor down to the closest integer element-wise."""
     return x.__floor__()
 
 
+def floor_divide(input, other):
+    r"""
+    Divides the first input tensor by the second input tensor element-wise and round down to the closest integer.
+    """
+    return F.floor_divide(input, other)
+
+
 def uadd(x):
     """Implementation of `uadd`."""
     return x.__pos__()
@@ -2775,19 +2804,25 @@ def bool_(x):
     return x.__bool__()
 
 
+def check_len_(x):
+    """Check length is not 0"""
+    return x.__len__() != 0
+
+
+def real_bool_(x):
+    """bool function to get truth value"""
+    return bool(x)
+
+
 def enumerate_(x, start=0):
     """Enumerate list or tuple or tensor."""
     x_type = F.typeof(x)
     ret = ()
     op_name = "enumerate"
-    if check_is_tuple_or_list_or_tensor(x_type, op_name, "first input") and \
-            check_is_const_int(start, op_name, "start"):
+    if check_is_const_int(start, op_name, "start"):
         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
@@ -2857,12 +2892,19 @@ def to_coo(x):
     return F.dense_to_sparse_coo(x)
 
 
+def tolist(x):
+    """
+    Convert a Tensor to List, if the input is Tensor scalar, Python scalar will be returned.
+    """
+    return x.asnumpy().tolist()
+
+
 @constexpr
 def check_select_condition(cond_type):
     """
     Check select input condition.
     """
-    if isinstance(cond_type, mstype.tensor_type):
+    if isinstance(cond_type, mstype.TensorType):
         return
     raise TypeError(
         f"For select, the argument condition should be Tensor, but got {cond_type}.")
@@ -3015,15 +3057,6 @@ def ge(x, y):
     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 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_)
-    return x
-
-
 def tensor_scatter_add(x, indices, updates):
     """
     Creates a new tensor by adding the values from the positions in `x` indicated by
@@ -3216,7 +3249,7 @@ def get_itemsize(x_type):
 @constexpr(check=False)
 def check_is_tensor(x):
     """check whether x is tensor."""
-    if isinstance(x, mstype.tensor_type):
+    if isinstance(x, mstype.TensorType):
         return True
     return False
 
@@ -3224,13 +3257,12 @@ def check_is_tensor(x):
 @constexpr
 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)):
+    if isinstance(x, (mstype.List, mstype.Tuple, mstype.TensorType)):
         return True
     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:
@@ -3242,17 +3274,6 @@ def check_is_const_int(x, op_name, arg_name):
     return True
 
 
-@_primexpr
-def check_is_tensor_bool_cond(shp):
-    """check if tensor is a bool condition"""
-    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
@@ -3286,7 +3307,6 @@ def check_view_shape(x):
 
 
 check_astype_dtype_const = constexpr(validator.check_astype_dtype)
-check_transpose_axis_const = constexpr(validator.check_transpose_axis)
 max_ = constexpr(validator.max_)
 min_ = constexpr(validator.min_)
 expanded_shape = validator.expanded_shape
@@ -3308,7 +3328,7 @@ def empty_compile(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))
+    is_cond = F.is_tensor_bool_cond(x)
     if is_cond and F.isconstant(x):
         return const_tensor_to_bool(x)
     return F.cast(x, mstype.bool_)
@@ -3433,21 +3453,6 @@ def sequence_index(sequence, target, start=None, end=None):
     return SequenceIndex()(sequence, target, start, end)
 
 
-def list_bool(x):
-    """Implementation of `tuple_bool`."""
-    return len(x) != 0
-
-
-def tuple_bool(x):
-    """Implementation of `tuple_bool`."""
-    return len(x) != 0
-
-
-def dict_bool(x):
-    """Implementation of `dict_bool`."""
-    return len(x) != 0
-
-
 def none_bool(x):
     """Implementation of `none_bool`."""
     return False
@@ -3517,7 +3522,7 @@ def triu(input, diagonal=0):
 
 def tuple_next(xs):
     """Next tuple."""
-    return xs[0], tail(xs)
+    return xs[0], xs[1:]
 
 
 def tuple_hasnext(xs):
@@ -3527,7 +3532,7 @@ def tuple_hasnext(xs):
 
 def list_next(xs):
     """Next list."""
-    return xs[0], tail(xs)
+    return xs[0], xs[1:]
 
 
 def list_hasnext(xs):
@@ -3571,7 +3576,7 @@ def list_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):
+    if F.is_sequence_shape_unknown(self_) or not F.isconstant(index):
         return ListInsert()(self_, index, obj)
     return _insert(self_, index, obj)
 
@@ -3604,6 +3609,11 @@ def dict_get(self_, key_index, default_value=None):
     return F.dict_getitem(self_, key_index)
 
 
+def dict_setitem(self_, key, target):
+    """Dictionary setitem"""
+    return _dict_setitem(self_, key, target)
+
+
 def dict_clear(self_):
     """Clear the dict"""
     return _dict_clear(self_)
@@ -3733,7 +3743,6 @@ 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(input, p, seed)
 
 
@@ -3802,6 +3811,14 @@ def xlogy(x, y):
     return F.xlogy(x, y)
 
 
+def eigvals(x):
+    r"""
+    Computes the eigenvalues of a square matrix(batch square matrices).
+    Refer to :func:`mindspore.ops.eigvals` for more detail.
+    """
+    return F.eigvals(x)
+
+
 def erf(x):
     r"""
     Computes the Gauss error function of `x` element-wise.
@@ -3847,6 +3864,13 @@ def cos(x):
     return F.cos(x)
 
 
+def count_nonzero(x, axis=(), keep_dims=False, dtype=mstype.int32):
+    r"""
+    For details, please refer to :func:`mindspore.ops.count_nonzero`.
+    """
+    return F.count_nonzero(x, axis, keep_dims, dtype)
+
+
 def cov(x, *, correction=1, fweights=None, aweights=None):
     r"""
     For details, please refer to :func:`mindspore.ops.cov`.
@@ -3907,7 +3931,7 @@ 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=beta, alpha=alpha)
+    return F.addmv(x, mat, vec, beta=beta, alpha=beta)
 
 
 def adjoint(x):
@@ -4015,6 +4039,14 @@ def cholesky_inverse(input_x, upper=False):
     return F.cholesky_inverse(input_x, upper=upper)
 
 
+def cholesky_solve(input, input2, upper=False):
+    r"""
+    Computes the solution of a set of linear equations with a positive definite matrix,
+    according to its Cholesky decomposition factor `input2` .
+    """
+    return F.cholesky_solve(input, input2, 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.
@@ -4117,7 +4149,8 @@ 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)
+    size = P.TensorToTuple()(size)
+    return F.broadcast_to(input, size)
 
 
 def cumprod(input, dim, dtype=None):
@@ -4139,6 +4172,13 @@ def div(input, value, *, rounding_mode=None):
     return F.div(input, value, rounding_mode=rounding_mode)
 
 
+def eq(input, other):
+    r"""
+    Computes the equivalence between the tensor `input` and the given input tensor `other` element-wise.
+    """
+    return F.equal(input, other)
+
+
 def equal(x, y):
     r"""
     Computes the equivalence between the tensor `x` and the given input tensor `y` element-wise.
@@ -4413,6 +4453,13 @@ def qr(input, some=True):
     return F.qr(input, 'reduced' if some else 'complete')
 
 
+def ormqr(input, input2, input3, left=True, transpose=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.ormqr`.
+    """
+    return F.ormqr(input, input2, input3, left, transpose)
+
+
 def amax(input, axis=None, keep_dims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.amax`.
@@ -4425,3 +4472,61 @@ def amin(input, axis=None, keep_dims=False):
     For details, please refer to :func:`mindspore.ops.amin`.
     """
     return F.amin(input, axis, keep_dims)
+
+
+def lu_solve(b, LU_data, LU_pivots):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.lu_solve`
+    """
+    return F.lu_solve(b, LU_data, LU_pivots)
+
+
+def masked_scatter(input, mask, tensor):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.masked_scatter`
+    """
+    return array_ops.MaskedScatter()(input, mask, tensor)
+
+
+def index_put(input, indices, values, accumulate=False):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.index_put`
+    """
+    check_bool_type(accumulate, 'accumulate', 'Tensor.index_put')
+    _index_put = array_ops.IndexPut(0 if accumulate is False else 1)
+    return _index_put(input, values, indices)
+
+
+def aminmax(input, *, axis=0, keepdims=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.aminmax`.
+    """
+    return F.aminmax(input, axis=axis, keepdims=keepdims)
+
+
+def quantile(input, q, axis=None, keepdims=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.quantile`.
+    """
+    return F.quantile(input, q, axis, keepdims)
+
+
+def nanquantile(input, q, axis=None, keepdims=False):
+    r"""
+    For details, please refer to :func:`mindspore.ops.nanquantile`.
+    """
+    return F.nanquantile(input, q, axis, keepdims)
+
+
+def orgqr(input, input2):
+    r"""
+    For details, please refer to :func:`mindspore.ops.orgqr`.
+    """
+    return F.orgqr(input, input2)
+
+
+def outer(input, vec2):
+    r"""
+    For details, please refer to :func:`mindspore.ops.vec2`.
+    """
+    return F.outer(input, vec2)