mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/numpy/math_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2021 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -79,7 +79,7 @@ def absolute(x, dtype=None):
         Numpy arguments `out`, `where`, `casting`, `order`, `subok`, `signature`, and `extobj` are
         not supported.
         Currently the backend kernel only supports float calculation, if the input
-        is not a `float`, then it will be casted to :class:`mstype.float32` and casted back.
+        is not a `float`, then it will be casted to ``mstype.float32`` and casted back.
 
     Args:
         x (Tensor): Tensor to be used for calculation.
@@ -295,7 +295,7 @@ def add(x1, x2, dtype=None):
     # broadcast is not fully supported in tensor_add on CPU,
     # so we use tensor_sub as a substitute solution
     if _get_device() == 'CPU':
-        return subtract(x1, F.neg_tensor(_to_tensor(x2)), dtype=dtype)
+        return subtract(x1, F.neg(_to_tensor(x2)), dtype=dtype)
     return _apply_tensor_op(F.tensor_add, x1, x2, dtype=dtype)
 
 
@@ -604,14 +604,14 @@ def mean(a, axis=None, keepdims=False, dtype=None):
     Args:
         a (Tensor): input tensor containing numbers whose mean is desired.
                     If a is not an array, a conversion is attempted.
-        axis (None or int or tuple of integers, optional): Axis or axes along
+        axis (Union[int, tuple(int), None], optional): Axis or axes along
                     which the means are computed. The default is to compute
                     the mean of the flattened array. If this is a tuple of
-                    ints, a mean is performed over multiple axes.
+                    ints, a mean is performed over multiple axes. Default: ``None`` .
         keepdims (bool, optional): 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 tensor.
+                    correctly against the input tensor. Default: ``False`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
@@ -902,7 +902,7 @@ def std(x, axis=None, ddof=0, keepdims=False):
 
             If ``None`` , compute the standard deviation of the flattened array.
         ddof (int): Means Delta Degrees of Freedom. The divisor used in calculations is :math:`N - ddof`,
-            where :math:`N` represents the number of elements. Default: 0.
+            where :math:`N` represents the number of elements. Default: ``0``.
         keepdims: 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 tensor.
             If the default value is passed, then keepdims will not be passed through to the std method of
@@ -1011,14 +1011,14 @@ def average(x, axis=None, weights=None, returned=False):
 
     Args:
         x (Tensor): A Tensor to be averaged.
-        axis (Union[None, int, tuple(int)]): Axis along which to average `x`. Default: ``None`` .
+        axis (Union[None, int, tuple(int)], optional): Axis along which to average `x`. Default: ``None`` .
             If the axis is `None`, it will average over all of the elements of the tensor `x`.
             If the axis is negative, it counts from the last to the first axis.
-        weights (Union[None, Tensor]): Weights associated with the values in `x`. Default: ``None`` .
+        weights (Union[None, Tensor], optional): Weights associated with the values in `x`. Default: ``None`` .
             If `weights` is `None`, all the data in `x` are assumed to have a weight equal to one.
             If `weights` is 1-D tensor, the length must be the same as the given axis.
             Otherwise, `weights` should have the same shape as `x`.
-        returned (bool): Default: ``False`` .
+        returned (bool, optional): Default: ``False`` .
             If `True`, the tuple (average, sum_of_weights) is returned.
             If `False`, only the average is returned.
 
@@ -1154,7 +1154,7 @@ def square(x, dtype=None):
 
     Returns:
         Tensor or scalar, element-wise ``x*x``, of the same shape and dtype as `x`.
-        This is a scalar if `x` is a scalar..
+        This is a scalar if `x` is a scalar.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1402,7 +1402,7 @@ def amax(a, axis=None, keepdims=False, initial=None, where=True):
 
     Args:
         a (Tensor): Input data.
-        axis (None or int or tuple of integers, optional): Default: ``None`` . Axis or
+        axis (Union[int, tuple(int), None], optional): Default: ``None`` . Axis or
             axes along which to operate. By default, flattened input is used. If
             this is a tuple of integers, the maximum is selected over multiple axes,
             instead of a single axis or all the axes as before.
@@ -1458,7 +1458,7 @@ def amin(a, axis=None, keepdims=False, initial=None, where=True):
 
     Args:
         a (Tensor): Input data.
-        axis (None or int or tuple of integers, optional): Default: ``None`` . Axis or
+        axis (Union[int, tuple(int), None], optional): Default: ``None`` . Axis or
             axes along which to operate. By default, flattened input is used. If
             this is a tuple of integers, the minimum is selected over multiple axes,
             instead of a single axis or all the axes as before.
@@ -1552,7 +1552,7 @@ def hypot(x1, x2, dtype=None):
         if _get_device() == 'CPU':
             # broadcast is not fully supported in tensor_add on CPU,
             # so we use tensor_sub as a substitute solution
-            return F.sqrt(F.tensor_sub(F.square(x1), F.neg_tensor(F.square(x2))))
+            return F.sqrt(F.tensor_sub(F.square(x1), F.neg(F.square(x2))))
         return F.sqrt(F.tensor_add(F.square(x1), F.square(x2)))
 
     return _apply_tensor_op(_hypot, x1, x2, dtype=dtype)
@@ -1716,7 +1716,7 @@ def fix(x):
         x = F.cast(x, mstype.float32)
     floored = F.floor(x)
     # change to F.ceil once supported on CPU.
-    ceiled = F.neg_tensor(F.floor(F.neg_tensor(x)))
+    ceiled = F.neg(F.floor(F.neg(x)))
     is_neg = F.tensor_lt(x, zeros(F.shape(x), F.dtype(x)))
     return F.select(is_neg, ceiled, floored)
 
@@ -1992,10 +1992,10 @@ def ediff1d(ary, to_end=None, to_begin=None):
 
     Args:
         ary (Tensor): If necessary, will be flattened before the differences are taken.
-        to_end (Tensor or scalar, optional): Number(s) to append at the end of the
-            returned differences.
-        to_begin (Tensor or scalar, optional): Number(s) to prepend at the beginning
-            of the returned differences.
+        to_end (Tensor, scalar, optional): Number(s) to append at the end of the
+            returned differences. Default: ``None`` .
+        to_begin (Tensor, scalar, optional): Number(s) to prepend at the beginning
+            of the returned differences. Default: ``None`` .
 
     Returns:
         The differences.
@@ -2432,7 +2432,7 @@ def _shape_reduced(shape, axes):
     """Removes dimensions corresponding to argument axes"""
     ndim_orig = F.tuple_len(shape)
     ndim_out = ndim_orig - F.tuple_len(axes)
-    shape_out = [0]*ndim_out
+    shape_out = [0] * ndim_out
     idx_out = 0
     for i in range(ndim_orig):
         if i not in axes:
@@ -2499,8 +2499,8 @@ def nanmax(a, axis=None, dtype=None, keepdims=False):
     Args:
         a (Union[int, float, list, tuple, Tensor]): Array containing numbers whose maximum
             is desired. If `a` is not an array, a conversion is attempted.
-        axis (Union[int, tuple of int, None], optional): Axis or axes along which the maximum is
-            computed. The default is to compute the maximum of the flattened array.
+        axis (Union[int, tuple(int), None], optional): Axis or axes along which the maximum is
+            computed. The default is to compute the maximum of the flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         keepdims (boolean, optional): Default: ``False`` . If this is set to True, the axes which
@@ -2531,7 +2531,7 @@ def nanmax(a, axis=None, dtype=None, keepdims=False):
     if not isinstance(keepdims, int):
         _raise_type_error("integer argument expected, got", keepdims)
     nan_mask = _isnan(a)
-    a = F.select(nan_mask, full(F.shape(a), -sys.maxsize - 1, F.dtype(a)), a)
+    a = F.select(nan_mask, P.FillV2()(F.shape(a), Tensor(-sys.maxsize - 1, F.dtype(a))), a)
     reduce_fn = _reduce_max_keepdims if keepdims else _reduce_max_default
     return _reduce(a, reduce_fn, axis=axis, keepdims=keepdims, dtype=dtype)
 
@@ -2549,8 +2549,8 @@ def nanmin(a, axis=None, dtype=None, keepdims=False):
     Args:
         a (Union[int, float, list, tuple, Tensor]): Array containing numbers whose minimum
             is desired. If `a` is not an array, a conversion is attempted.
-        axis (Union[int, tuple of int, None], optional): Axis or axes along which the minimum is
-            computed. The default is to compute the minimum of the flattened array.
+        axis (Union[int, tuple(int), None], optional): Axis or axes along which the minimum is
+            computed. The default is to compute the minimum of the flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         keepdims (boolean, optional): Default: ``False`` . If this is set to True, the axes which
@@ -2581,7 +2581,7 @@ def nanmin(a, axis=None, dtype=None, keepdims=False):
     if not isinstance(keepdims, int):
         _raise_type_error("integer argument expected, got", keepdims)
     nan_mask = _isnan(a)
-    a = F.select(nan_mask, full(F.shape(a), sys.maxsize, F.dtype(a)), a)
+    a = F.select(nan_mask, P.FillV2()(F.shape(a), Tensor(sys.maxsize, F.dtype(a))), a)
     reduce_fn = _reduce_min_keepdims if keepdims else _reduce_min_default
     return _reduce(a, reduce_fn, axis=axis, keepdims=keepdims, dtype=dtype)
 
@@ -2605,7 +2605,7 @@ def nansum(a, axis=None, dtype=None, keepdims=False):
         a (Union[int, float, list, tuple, Tensor]): Array containing numbers
             whose sum is desired. If `a` is not an array, a conversion is attempted.
         axis (Union[int, tuple of int, None], optional): Axis or axes along which the sum is
-            computed. The default is to compute the sum of the flattened array.
+            computed. The default is to compute the sum of the flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         keepdims (boolean, optional): Default: ``False`` . If this is set to True, the axes which
@@ -2662,7 +2662,7 @@ def nanmean(a, axis=None, dtype=None, keepdims=False):
         a (Union[int, float, list, tuple, Tensor]): Array containing numbers
             whose mean is desired. If `a` is not an array, a conversion is attempted.
         axis (Union[int, tuple of int, None], optional): Axis or axes along which the mean is
-            computed. The default is to compute the mean of the flattened array.
+            computed. The default is to compute the mean of the flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         keepdims (boolean, optional): Default: ``False`` . If this is set to True, the axes which
@@ -2724,7 +2724,7 @@ def nanvar(a, axis=None, dtype=None, ddof=0, keepdims=False):
         a (Union[int, float, list, tuple, Tensor]): Array containing numbers
             whose variance is desired. If `a` is not an array, a conversion is attempted.
         axis (Union[int, tuple of int, None], optional): Axis or axes along which the variance is
-            computed. The default is to compute the variance of the flattened array.
+            computed. The default is to compute the variance of the flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         ddof (int, optional): "Delta Degrees of Freedom": the divisor used in the calculation is
@@ -2779,7 +2779,7 @@ def nanstd(a, axis=None, dtype=None, ddof=0, keepdims=False):
         a (Union[int, float, list, tuple, Tensor]): Calculates the standard deviation of the non-NaN values.
         axis (Union[int, tuple of int, None], optional): Axis or axes along which the standard
             deviation is computed. The default is to compute the standard deviation of the
-            flattened array.
+            flattened array. Default: ``None`` .
         dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
         ddof (int, optional): "Delta Degrees of Freedom": the divisor used in the calculation is
@@ -2894,9 +2894,9 @@ def kron(a, b):
 
     # scales a by the shape of b
     kron_shape = _seq_prod(shape_a, shape_b)
-    a = F.reshape(a, _add_unit_axes(shape_a, 2*ndim, True))
-    a = F.tile(a, _add_unit_axes(shape_b, 2*ndim, False))
-    a = moveaxis(a, F.make_range(ndim, 2*ndim), F.make_range(1, 2*ndim, 2))
+    a = F.reshape(a, _add_unit_axes(shape_a, 2 * ndim, True))
+    a = F.tile(a, _add_unit_axes(shape_b, 2 * ndim, False))
+    a = moveaxis(a, F.make_range(ndim, 2 * ndim), F.make_range(1, 2 * ndim, 2))
     a = F.reshape(a, kron_shape)
     # scales b by the shape of a
     b = F.tile(b, shape_a)
@@ -2997,11 +2997,11 @@ def cross(a, b, axisa=- 1, axisb=- 1, axisc=- 1, axis=None):
         cx = F.tensor_sub(_get_slice_product(1, 2), _get_slice_product(2, 1)) # ay*bz - az*by
         cy = F.tensor_sub(_get_slice_product(2, 0), _get_slice_product(0, 2)) # az*bx - ax*bz
     elif a_has_z:
-        cx = F.neg_tensor(_get_slice_product(2, 1)) # -az*by
+        cx = F.neg(_get_slice_product(2, 1)) # -az*by
         cy = _get_slice_product(2, 0)               # az*bx
     else: # b_has_z
         cx = _get_slice_product(1, 2)               # ay*bz
-        cy = F.neg_tensor(_get_slice_product(0, 2)) # -ax*bz
+        cy = F.neg(_get_slice_product(0, 2)) # -ax*bz
     res = _concat((cx, cy, cz)).reshape(shape_out)
     return moveaxis(res, -1, axisc).astype(dtype)
 
@@ -3035,7 +3035,7 @@ def ceil(x, dtype=None):
         >>> print(output)
         [-1. -1. -0.  1.  2.  2.  2.]
     """
-    return _apply_tensor_op(lambda x: F.neg_tensor(F.floor(F.neg_tensor(x.astype(mstype.float32)))),
+    return _apply_tensor_op(lambda x: F.neg(F.floor(F.neg(x.astype(mstype.float32)))),
                             x, dtype=dtype)
 
 
@@ -3080,8 +3080,8 @@ def positive(a, dtype=None):
         [1. -1.]
     """
     _check_input_tensor(a)
-    neg_tensor = F.neg_tensor(a)
-    return _apply_tensor_op(F.neg_tensor, neg_tensor, dtype=dtype)
+    neg_tensor = F.neg(a)
+    return _apply_tensor_op(F.neg, neg_tensor, dtype=dtype)
 
 
 def negative(a, dtype=None):
@@ -3110,7 +3110,7 @@ def negative(a, dtype=None):
         >>> print(output)
         [-1. 1.]
     """
-    return _apply_tensor_op(F.neg_tensor, a, dtype=dtype)
+    return _apply_tensor_op(F.neg, a, dtype=dtype)
 
 
 def cumsum(a, axis=None, dtype=None):
@@ -3118,8 +3118,8 @@ def cumsum(a, axis=None, dtype=None):
     Returns the cumulative sum of the elements along a given axis.
 
     Note:
-        If ``a.dtype`` is :class:`int8`, :class:`int16` or :class:`bool`, the result
-        `dtype` will be elevated to :class:`int32`.
+        If ``a.dtype`` is `int8`, `int16` or `bool`, the result
+        `dtype` will be elevated to `int32`.
 
     Args:
         a (Tensor): Input tensor.
@@ -3161,8 +3161,8 @@ def nancumsum(a, axis=None, dtype=None):
     Zeros are returned for slices that are all-NaN or empty.
 
     Note:
-        If ``a.dtype`` is :class:`int8`, :class:`int16` or :class:`bool`, the result
-        `dtype` will be elevated to :class:`int32`.
+        If ``a.dtype`` is `int8`, `int16` or `bool`, the result
+        `dtype` will be elevated to `int32`.
 
     Args:
         a (Tensor): Input tensor.
@@ -3171,7 +3171,7 @@ def nancumsum(a, axis=None, dtype=None):
         dtype (:class:`mindspore.dtype`, optional): If not specified, stay the same as `a`,
             unless `a` has an integer dtype with a precision less than that of the
             default platform integer. In that case, the default platform integer
-            is used.
+            is used. Default: ``None`` .
 
     Returns:
         Tensor.
@@ -3231,7 +3231,7 @@ def cbrt(x, dtype=None):
     def _cbrt(x):
         compute_type = promote_types(x.dtype, "float32")
         x = x.astype(compute_type)
-        # TODO: use P.Sign() once gpu support is added
+        # use P.Sign() once gpu support is added
         abs_x = F.absolute(x)
         sign_x = abs_x / x
         return sign_x * F.tensor_pow(abs_x, 1. / 3.)
@@ -3271,12 +3271,7 @@ def log1p(x, dtype=None):
 
 def logaddexp(x1, x2, dtype=None):
     """
-    Logarithm of the sum of exponentiations of the inputs.
-
-    Calculates ``log(exp(x1) + exp(x2))``. This function is useful in statistics where the
-    calculated probabilities of events may be so small as to exceed the range of normal
-    floating point numbers. In such cases the logarithm of the calculated probability is
-    stored. This function allows adding probabilities stored in such a fashion.
+    Logarithm of the sum of exponentiations of the inputs. Calculates ``log(exp(x1) + exp(x2))``.
 
     Note:
         Numpy arguments `out`, `where`, `casting`, `order`, `subok`, `signature`, and `extobj` are
@@ -3502,7 +3497,7 @@ def tan(x, dtype=None):
         Tensor or scalar. This is a scalar if `x` is a scalar.
 
     Raises:
-        TypeError: If the input is not a tensor or is :class:`tensor.dtype` is :class:`mindspore.float64`.
+        TypeError: If the input is not a tensor or the dtype of tensor is mindspore.float64.
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -3937,11 +3932,11 @@ def _gradient_along_axis(f, h, axis):
     """compute the gradients of `f` along a given axis, a helper function of gradient."""
     end = f.shape[axis]
     upper_edge = _slice_along_axis(f, axis, 1, 2) - _slice_along_axis(f, axis, 0, 1)
-    lower_edge = _slice_along_axis(f, axis, end-1, end) - _slice_along_axis(f, axis, end-2, end-1)
+    lower_edge = _slice_along_axis(f, axis, end - 1, end) - _slice_along_axis(f, axis, end - 2, end - 1)
     if end <= 2:
         a_grad = concatenate((upper_edge, lower_edge), axis)
     else:
-        middle = (_slice_along_axis(f, axis, 2, end) - _slice_along_axis(f, axis, 0, end-2)) * 0.5
+        middle = (_slice_along_axis(f, axis, 2, end) - _slice_along_axis(f, axis, 0, end - 2)) * 0.5
         a_grad = concatenate((upper_edge, middle, lower_edge), axis)
     return a_grad / h
 
@@ -3983,10 +3978,10 @@ def gradient(f, *varargs, axis=None, edge_order=1):
             1. single scalar to specify a sample distance for all dimensions.
             2. N scalars to specify a constant sample distance for each dimension.
         axis (Union[None, int, tuple(int), list(int)], optional): Gradient is calculated
-            only along the given axis or axes. The default :class:`(axis = None)` is to calculate
+            only along the given axis or axes. The default ``(axis = None)`` is to calculate
             the gradient for all the axes of the input tensor. `axis` may be negative,
             in which case it counts from the last to the first `axis`.
-        edge_order (int): Gradient is calculated using N-th order accurate differences
+        edge_order (int, optional): Gradient is calculated using N-th order accurate differences
             at the boundaries. Default: ``1`` .
 
     Returns:
@@ -4055,21 +4050,22 @@ def sum_(a, axis=None, dtype=None, keepdims=False, initial=None):
         `extobj` are not supported.
 
     Args:
-        x (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`.
+        a (Union[int, float, bool, list, tuple, Tensor]): Elements to sum.
+        axis (Union[None, int, tuple(int)], optional): 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 integers, a sum is performed on all of the axes specified in the tuple
             instead of a single axis or all the axes as before.
         dtype (:class:`mindspore.dtype`, optional): Defaults to `None`. Overrides the dtype of the
             output Tensor.
-        keepdims (bool): If this is set to True, the axes which are reduced are left in the result as
+        keepdims (bool, optional): 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.
             If the default value is passed, then keepdims will not be passed through to the sum method of
             sub-classes of ndarray, however any non-default value will be. If the sub-class method does not
-            implement keepdims any exceptions will be raised. Default: `False`.
-        initial (scalar): Starting value for the sum, if `None`, which refers to the first element of the reduction.
-            Default: `None`.
+            implement keepdims any exceptions will be raised. Default: ``False``.
+        initial (scalar, optional): Starting value for the sum, if `None`,
+            which refers to the first element of the reduction.
+            Default: ``None``.
 
     Returns:
         Tensor. An array with the same shape as a, with the specified axis removed.
@@ -4104,8 +4100,8 @@ def _min_cost_chain_matmul(dims):
     """
     dims = tuple(dims)
     n = len(dims) - 1
-    m = [[0]*n for _ in range(n)]
-    s = [[0]*n for _ in range(n)]
+    m = [[0] * n for _ in range(n)]
+    s = [[0] * n for _ in range(n)]
     for pos in range(1, n):
         for i in range(n - pos):
             j = i + pos
@@ -4171,18 +4167,18 @@ def multi_dot(arrays):
     Examples:
         >>> import mindspore.numpy as np
         >>> A = np.ones((10000, 100))
-        >>> B = np.ones((100, 1000))
-        >>> C = np.ones((1000, 5))
+        >>> B = np.ones((100, 100))
+        >>> C = np.ones((100, 5))
         >>> D = np.ones((5, 333))
         >>> output = np.multi_dot([A, B, C, D])
         >>> print(output)
-        [[500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
+        [[50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
         ...
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]
-        [500000. 500000. 500000. ... 500000. 500000. 500000.]]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]
+        [50000. 50000. 50000. ... 50000. 50000. 50000.]]
     """
     if len(arrays) < 2:
         _raise_value_error('Expecting at least 2 arrays')
@@ -4285,7 +4281,7 @@ def argmin(a, axis=None):
 
     Examples:
         >>> import mindspore.numpy as np
-        >>> a = np.arange(10, 16).reshape(2, 3).astype(np.float32)
+        >>> a = np.arange(10, 16).reshape(2, 3)
         >>> print(np.argmin(a))
         0
         >>> print(np.argmin(a, axis=0))
@@ -4314,12 +4310,12 @@ def searchsorted(a, v, side='left', sorter=None):
             None, then it must be sorted in ascending order, otherwise `sorter` must be
             an array of indices that sort it.
         v (Union[int, float, bool, list, tuple, Tensor]): Values to insert into `a`.
-        side ('left', 'right', optional): If ``'left'`` , the index of the first suitable
+        side ('left', 'right', optional): If ``'left'`` (default value), the index of the first suitable
             location found is given. If ``'right'`` , return the last such index. If there is
             no suitable index, return either 0 or N (where N is the length of `a`).
         sorter (Union[int, float, bool, list, tuple, Tensor]): 1-D optional array of
             integer indices that sort array `a` into ascending order. They are typically
-            the result of argsort.
+            the result of argsort. Default: ``None`` .
 
     Returns:
         Tensor, array of insertion points with the same shape as `v`.
@@ -4383,9 +4379,9 @@ def interp(x, xp, fp, left=None, right=None):
         fp (Union[int, float, bool, list, tuple, Tensor]): 1-D sequence of floats, the
             y-coordinates of the data points, same length as `xp`.
         left (float, optional): Value to return for ``x < xp[0]``, default is ``fp[0]``
-            once obtained.
+            once obtained. Default: ``None`` .
         right (float, optional): Value to return for ``x > xp[-1]``, default is ``fp[-1]``
-            once obtained.
+            once obtained. Default: ``None`` .
 
     Returns:
         Tensor, the interpolated values, same shape as `x`.
@@ -4426,7 +4422,7 @@ def interp(x, xp, fp, left=None, right=None):
     x_1 = F.gather_nd(xp, indices_1)
     y_0 = F.gather_nd(fp, indices_0)
     y_1 = F.gather_nd(fp, indices_1)
-    res = (y_0*(x_1 - x) + y_1*(x - x_0))/(x_1 - x_0)
+    res = (y_0 * (x_1 - x) + y_1 * (x - x_0)) / (x_1 - x_0)
     res = F.select(F.equal(x_0, x_1), y_0, res)
 
     idx_0 = _to_tensor([0])
@@ -4554,7 +4550,7 @@ def copysign(x1, x2, dtype=None):
     else:
         pos_tensor = F.absolute(x1)
 
-    neg_tensor = F.neg_tensor(pos_tensor)
+    neg_tensor = F.neg(pos_tensor)
     less_zero = F.less(x2, 0)
     res = F.select(less_zero, neg_tensor, pos_tensor)
 
@@ -4690,21 +4686,21 @@ def histogram(a, bins=10, range=None, weights=None, density=False): # pylint: di
         bins (Union[int, tuple, list, Tensor], optional): If `bins` is an int, it
             defines the number of equal-width bins in the given range (10, by
             default). If `bins` is a sequence, it defines the bin edges, including
-            the rightmost edge, allowing for non-uniform bin widths.
+            the rightmost edge, allowing for non-uniform bin widths. Default: ``10`` .
         range((float, float), optional): The lower and upper range of the bins. If
             not provided, `range` is simply ``(a.min(), a.max())``. Values outside
             the range are ignored. The first element of the range must be less than
-            or equal to the second.
+            or equal to the second. Default: ``None`` .
         weights (Union[int, float, bool, list, tuple, Tensor], optional): An array
             of weights, of the same shape as `a`. If density is True, the weights
             are normalized, so that the integral of the density over the range
-            remains 1.
+            remains 1. Default: ``None`` .
         density (boolean, optional): If False, the result will contain the number of
             samples in each bin. If True, the result is the value of the probability
             density function at the bin, normalized such that the integral over the
             range is 1. Note that the sum of the histogram values will not be equal
             to 1 unless bins of unity width are chosen; it is not a probability mass
-            function.
+            function. Default: ``False`` .
 
     Returns:
         (Tensor, Tensor), the values of the histogram and the bin edges.
@@ -4744,7 +4740,7 @@ def histogram(a, bins=10, range=None, weights=None, density=False): # pylint: di
         return count, bin_edges
     if density:
         count = F.cast(count, mstype.float32)
-        count = count/diff(bin_edges)/F.reduce_sum(count)
+        count = count / diff(bin_edges) / F.reduce_sum(count)
     return count, bin_edges
 
 
@@ -4800,7 +4796,7 @@ def histogramdd(sample, bins=10, range=None, weights=None, density=False): # pyl
             such as ``histogramdd((X, Y, Z))``.
 
             The first form should be preferred.
-        bins (Union[int, tuple, list], optional): The bin specification:
+        bins (Union[int, tuple, list], optional): Default: ``10`` . The bin specification:
 
             A sequence of arrays describing the monotonically increasing bin edges along
             each dimension.
@@ -4812,12 +4808,12 @@ def histogramdd(sample, bins=10, range=None, weights=None, density=False): # pyl
             ``(lower, upper)`` tuple giving the outer bin edges to be used if the edges
             are not given explicitly in bins. An entry of None in the sequence results in
             the minimum and maximum values being used for the corresponding dimension.
-            The default, None, is equivalent to passing a tuple of `D` None values.
+            The default, None, is equivalent to passing a tuple of `D` None values. Default: ``None`` .
         weights (Union[list, tuple, Tensor], optional): An array with shape `(N,)` of values
-            `w_i` weighing each sample ``(x_i, y_i, z_i, …)``.
+            `w_i` weighing each sample ``(x_i, y_i, z_i, …)``. Default: ``None`` .
         density (boolean, optional): If False, the default, returns the number of samples
             in each bin. If True, returns the probability density function at the bin,
-            ``bin_count / sample_count / bin_volume``.
+            ``bin_count / sample_count / bin_volume``. Default: ``False`` .
 
     Returns:
         (Tensor, list of Tensor), the values of the histogram and the bin edges.
@@ -4904,7 +4900,7 @@ def histogram2d(x, y, bins=10, range=None, weights=None, density=False): # pylin
             coordinates of the points to be histogrammed.
         y (Union[list, tuple, Tensor]): An array with shape `(N,)` containing the y
             coordinates of the points to be histogrammed.
-        bins (Union[int, tuple, list], optional): The bin specification:
+        bins (Union[int, tuple, list], optional): Default: ``10`` . The bin specification:
 
             If int, the number of bins for the two dimensions ``(nx=ny=bins)``.
 
@@ -4919,12 +4915,12 @@ def histogram2d(x, y, bins=10, range=None, weights=None, density=False): # pylin
         range(Union[list, tuple], optional): has shape (2, 2), the leftmost and rightmost
             edges of the bins along each dimension (if not specified explicitly in the bins
             parameters): ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
-            will be considered outliers and not tallied in the histogram.
+            will be considered outliers and not tallied in the histogram. Default: ``None`` .
         weights (Union[list, tuple, Tensor], optional): An array with shape `(N,)` of values
-            `w_i` weighing each sample `(x_i, y_i)`.
+            `w_i` weighing each sample `(x_i, y_i)`. Default: ``None`` .
         density (boolean, optional): If False, the default, returns the number of samples
             in each bin. If True, returns the probability density function at the bin,
-            ``bin_count / sample_count / bin_volume``.
+            ``bin_count / sample_count / bin_volume``. Default: ``False`` .
 
     Returns:
         (Tensor, Tensor, Tensor), the values of the bi-directional histogram and the bin edges
@@ -5065,8 +5061,8 @@ def polyadd(a1, a2):
         Numpy object poly1d is currently not supported.
 
     Args:
-        a1 (Union[int, float, list, tuple, Tensor): Input polynomial.
-        a2 (Union[int, float, list, tuple, Tensor): Input polynomial.
+        a1 (Union[int, float, list, tuple, Tensor]): Input polynomial.
+        a2 (Union[int, float, list, tuple, Tensor]): Input polynomial.
 
     Returns:
         Tensor, the sum of the inputs.
@@ -5101,8 +5097,8 @@ def polysub(a1, a2):
         Numpy object poly1d is currently not supported.
 
     Args:
-        a1 (Union[int, float, list, tuple, Tensor): Minuend polynomial.
-        a2 (Union[int, float, list, tuple, Tensor): Subtrahend polynomial.
+        a1 (Union[int, float, list, tuple, Tensor]): Minuend polynomial.
+        a2 (Union[int, float, list, tuple, Tensor]): Subtrahend polynomial.
 
     Returns:
         Tensor, the difference of the inputs.
@@ -5118,7 +5114,7 @@ def polysub(a1, a2):
         >>> print(np.polysub([2, 10, -2], [3, 10, -4]))
         [-1  0  2]
     """
-    return polyadd(a1, F.neg_tensor(_to_tensor(a2)))
+    return polyadd(a1, F.neg(_to_tensor(a2)))
 
 
 def polyval(p, x):
@@ -5133,10 +5129,10 @@ def polyval(p, x):
         Numpy object poly1d is currently not supported.
 
     Args:
-        p (Union[int, float, bool, list, tuple, Tensor): 1D array of polynomial
+        p (Union[int, float, bool, list, tuple, Tensor]): 1D array of polynomial
             coefficients (including coefficients equal to zero) from highest
             degree to the constant term.
-        x (Union[int, float, bool, list, tuple, Tensor): A number, an array of
+        x (Union[int, float, bool, list, tuple, Tensor]): A number, an array of
             numbers, at which to evaluate `p`.
 
     Returns:
@@ -5157,7 +5153,7 @@ def polyval(p, x):
     shape = F.shape(x)
     exp_p = arange(_type_convert(int, p.size) - 1, -1, -1).astype(mstype.float32)
     var_p = (x.reshape(shape + (1,)))**exp_p
-    return F.reduce_sum(p*var_p, -1)
+    return F.reduce_sum(p * var_p, -1)
 
 
 def polyder(p, m=1):
@@ -5168,7 +5164,7 @@ def polyder(p, m=1):
         Numpy object poly1d is currently not supported.
 
     Args:
-        p (Union[int, float, bool, list, tuple, Tensor): Polynomial to differentiate.
+        p (Union[int, float, bool, list, tuple, Tensor]): Polynomial to differentiate.
             A sequence is interpreted as polynomial coefficients.
         m (int, optional): Default: ``1`` , order of differentiation.
 
@@ -5205,8 +5201,8 @@ def polymul(a1, a2):
         Numpy object poly1d is currently not supported.
 
     Args:
-        a1 (Union[int, float, bool, list, tuple, Tensor): Input polynomial.
-        a2 (Union[int, float, bool, list, tuple, Tensor): Input polynomial.
+        a1 (Union[int, float, bool, list, tuple, Tensor]): Input polynomial.
+        a2 (Union[int, float, bool, list, tuple, Tensor]): Input polynomial.
 
     Returns:
         Tensor, a new polynomial representing the derivative.
@@ -5235,10 +5231,10 @@ def polyint(p, m=1, k=None):
         Numpy object poly1d is currently not supported.
 
     Args:
-        p (Union[int, float, bool, list, tuple, Tensor): Polynomial to integrate. A
+        p (Union[int, float, bool, list, tuple, Tensor]): Polynomial to integrate. A
             sequence is interpreted as polynomial coefficients.
         m (int, optional): Defaults to 1, Order of the antiderivative.
-        k (Union[int, list of int]y, optinoal): Integration constants. They are given
+        k (Union[int, list[int]], optional): Integration constants. They are given
             in the order of integration: those corresponding to highest-order terms
             come first. If None (default), all constants are assumed to be zero. If
             ``m = 1``, a single scalar can be given instead of a list.
@@ -5342,7 +5338,7 @@ def unwrap(p, discont=3.141592653589793, axis=-1):
         differently than numpy due to differences in round-off.
 
     Args:
-        p (Union[int, float, bool, list, tuple, Tensor): Input array.
+        p (Union[int, float, bool, list, tuple, Tensor]): Input array.
         discont (float, optional): Maximum discontinuity between values, default: ``pi`` .
         axis (int, optional): Axis along which unwrap will operate, default: ``-1`` .
 
@@ -5370,9 +5366,9 @@ def unwrap(p, discont=3.141592653589793, axis=-1):
     axis = _check_axis_in_range(axis, ndim)
     dd = diff(p, axis=axis)
     ddmod = remainder(add(dd, pi), 2*pi) - pi
-    ddmod = F.masked_fill(ddmod, F.logical_and(ddmod == -pi, dd > 0), pi)
+    ddmod = F.masked_fill(ddmod, F.logical_and(ddmod == -pi, dd > 0), F.cast(pi, ddmod.dtype))
     ph_correct = ddmod - dd
-    ph_correct = F.masked_fill(ph_correct, absolute(dd) < discont, 0)
+    ph_correct = F.masked_fill(ph_correct, absolute(dd) < discont, F.cast(0, ph_correct.dtype))
     slice_all = _list_comprehensions(F.rank(p), F.make_slice(None, None, None), True)
     slice0 = _tuple_setitem(slice_all, axis, F.make_slice(0, 1, None))
     slice1 = _tuple_setitem(slice_all, axis, F.make_slice(1, None, None))
@@ -5477,14 +5473,14 @@ def ravel_multi_index(multi_index, dims, mode='clip', order='C'):
     Args:
         multi_index (tuple of array_like):
             A tuple of integer arrays, one array for each dimension.
-        dims (Union[int, tuple of integers]): The shape of array into which the indices from multi_index apply.
-        mode ({`wrap`, `clip`}): Specifies how out-of-bounds indices are handled. Default: ``clip''``.
+        dims (Union[int, tuple(int)]): The shape of array into which the indices from multi_index apply.
+        mode ({`wrap`, `clip`}, optional): Specifies how out-of-bounds indices are handled. Default: ``'clip'``.
 
             - `wrap`: wrap around
             - `clip`: clip to the range
 
             In `clip` mode, a negative index which would normally wrap will clip to 0 instead.
-        order ({`C`, `F`}): Determines whether the multi-index should be viewed as indexing in
+        order ({`C`, `F`}, optional): Determines whether the multi-index should be viewed as indexing in
             row-major (C-style) or column-major (Fortran-style) order.
 
     Returns:
@@ -5539,7 +5535,7 @@ def _vector_norm(x, _ord, axis, keepdims):
     elif _ord == 0:
         res = P.ReduceSum(keepdims)(F.not_equal(x, 0).astype(mstype.float32), axis)
     else:
-        res = power(P.ReduceSum(keepdims)(power(absolute(x), _ord), axis), 1./_ord)
+        res = power(P.ReduceSum(keepdims)(power(absolute(x), _ord), axis), 1. / _ord)
     return res
 
 
@@ -5586,7 +5582,7 @@ def norm(x, ord=None, axis=None, keepdims=False): # pylint: disable=redefined-bu
             the 2-norm of ``x.ravel`` will be returned.
         ord (Union[None, 'fro', 'nuc', inf, -inf, int, float], optional): Order of the norm.
             inf means numpy’s inf object. Default: ``None`` .
-        axis (Union[None, int, 2-tuple of integers], optional): If `axis` is an integer, it
+        axis (Union[int, 2-tuple(int), None], optional): If `axis` is an integer, it
             specifies the axis of `x` along which to compute the vector norms. If `axis` is
             a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of
             these matrices are computed. If `axis` is None then either a vector norm (when x
@@ -5800,72 +5796,71 @@ def rint(x, dtype=None):
 
 
 def correlate(a, v, mode='valid'):
-    """
+    r"""
     Cross-correlation of two 1-dimensional sequences.
 
     This function computes the correlation as generally defined in signal processing texts:
 
-    :math:`c_{av}[k] = sum_n a[n+k] * conj(v[n])`
+    :math:`c_{av}[k] = \sum_{n}{a[n+k] * conj(v[n])}`
 
     with `a` and `v` sequences being zero-padded where necessary and conj being the conjugate.
 
     Note:
-        Currently, complex numbers are not supported.
+        - `correlate` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `correlate` is not supported on Windows platform yet.
 
     Args:
         a (Union[list, tuple, Tensor]): First input sequence.
         v (Union[list, tuple, Tensor]): Second input sequence.
-        mode (str, optional): By default, mode is `\'valid\'`.
-            If `mode` is `\'valid\'`, it returns output of length :math:`max(M, N) - min(M, N) + 1`.
-            The convolution product is only given for points where the signals overlap
-            completely. Values outside the signal boundary have no effect.
-            If `mode` is `\'full\'`, it returns the convolution at each point of overlap, with
-            an output shape of :math:`(N + M - 1,)`.
-            At the end-points of the convolution, the signals do not overlap completely,
-            and boundary effects may be seen.
-            If `mode` is `\'same\'`, it returns output of length :math:`max(M, N)`. Boundary
-            effects are still visible.
+        mode (str, optional): Specifies padding mode. The optional values are
+            ``"same"`` , ``"valid"`` and ``"full"`` . Default: ``"valid"`` .
+
+            - ``"same"``: it returns output of length :math:`max(M, N)`. Boundary
+              effects are still visible.
+
+            - ``"valid"``: it returns output of length :math:`max(M, N) - min(M, N) + 1`.
+              The convolution product is only given for points where the signals overlap
+              completely. Values outside the signal boundary have no effect.
+
+            - ``"full"``: it returns the convolution at each point of overlap, with
+              an output shape of :math:`(N + M - 1,)`.At the end-points of the convolution,
+              the signals do not overlap completely, and boundary effects may be seen.
 
     Returns:
-        Tensor. Discrete cross-correlation of `a` and `v`.
+        Tensor, Discrete cross-correlation of `a` and `v`.
 
     Raises:
-        TypeError: If the inputs can not be converted to tensor.
+        TypeError: If `a` or `v` is not a tensor.
+        TypeError: If `a` and `v` is of different dtype.
         ValueError: If `a` and `v` are empty or have wrong dimensions
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.numpy as np
-        >>> output = np.correlate([1, 2, 3], [0, 1, 0.5])
+        >>> import mindspore.numpy as mnp
+        >>> from mindspore import Tensor
+        >>> output = mnp.correlate(Tensor([1., 2., 3.]), Tensor([0., 1., 0.5]))
         >>> print(output)
         [3.5]
-        >>> output = np.correlate([1, 2, 3], [0, 1, 0.5], mode="same")
+        >>> output = mnp.correlate(Tensor([1., 2., 3.]), Tensor([0., 1., 0.5]), mode="same")
         >>> print(output)
         [2.  3.5 3. ]
-        >>> output = np.correlate([1, 2, 3, 4, 5], [1, 2], mode="same")
+        >>> output = mnp.correlate(Tensor([1., 2., 3., 4., 5.]), Tensor([1., 2.]), mode="full")
         >>> print(output)
-        [ 2.  5.  8. 11. 14.]
-    """
-    a, v = _to_tensor(a, v)
-    if a.ndim != 1 or v.ndim != 1:
-        _raise_value_error("only support 1-dimensional inputs.")
-    if a.size == 0 or v.size == 0:
-        _raise_value_error("Inputs cannot be empty.")
+        [ 2.  5.  8. 11. 14.  5.]
+    """
+    if isinstance(a, list):
+        a = ops.auto_generate.list_to_tuple(a)
+    if isinstance(a, tuple):
+        a = ops.auto_generate.tuple_to_tensor(a)
+    if isinstance(v, list):
+        v = ops.auto_generate.list_to_tuple(v)
+    if isinstance(v, tuple):
+        v = ops.auto_generate.tuple_to_tensor(v)
+    return ops.auto_generate.correlate(a, v, mode)
 
-    promote_dtype = _promote(a.dtype, v.dtype)
-    # P.Conv2D requires that the two tensors have the same data type.
-    # If the promote data type is not supported, it will be converted to float32.
-    # The supported dtype list may vary in the future.
-    if promote_dtype not in [mstype.float32, mstype.float16]:
-        promote_dtype = mstype.float32
-    a = a.astype(promote_dtype)
-    v = v.astype(promote_dtype)
-    if a.size < v.size:
-        a, v = v, a
-        return _compute_1d_conv(a, v, mode)[::-1]
-    return _compute_1d_conv(a, v, mode)
 
 
 def _compute_1d_conv(a, v, mode):