mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.1__cp39-cp39-win_amd64.whl

mindspore/numpy/logic_ops.py

@@ -467,9 +467,9 @@ def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
     Args:
         a (Union[Tensor, list, tuple]): Input first tensor to compare.
         b (Union[Tensor, list, tuple]): Input second tensor to compare.
-        rtol (numbers.Number): The relative tolerance parameter (see Note).
-        atol (numbers.Number): The absolute tolerance parameter (see Note).
-        equal_nan (bool): Whether to compare ``NaN`` as equal. If True, ``NaN`` in
+        rtol (numbers.Number, optional): The relative tolerance parameter (see Note). Default: ``1e-05`` .
+        atol (numbers.Number, optional): The absolute tolerance parameter (see Note). Default: ``1e-08`` .
+        equal_nan (bool, optional): Whether to compare ``NaN`` as equal. If True, ``NaN`` in
             `a` will be considered equal to ``NaN`` in `b` in the output tensor.
             Default: ``False`` .
 
@@ -635,7 +635,7 @@ def logical_or(x1, x2, dtype=None):
             output Tensor.
 
     Returns:
-       Tensor or scalar, element-wise comparison of `x1` and `x2`. Typically of type
+       Tensor or scalar, logical OR operation of `x1` and `x2`. Typically of type
        bool, unless ``dtype=object`` is passed. This is a scalar if both `x1` and `x2` are
        scalars.
 
@@ -704,7 +704,7 @@ def logical_xor(x1, x2, dtype=None):
 
     Returns:
         Tensor or scalar.
-        Boolean result of the logical AND operation applied to the elements of `x1` and `x2`;
+        Boolean result of the logical XOR operation applied to the elements of `x1` and `x2`;
         the shape is determined by broadcasting. This is a scalar if both `x1` and `x2` are scalars.
 
     Supported Platforms:
@@ -733,12 +733,12 @@ def array_equal(a1, a2, equal_nan=False):
         In mindspore, a bool tensor is returned instead, since in Graph mode, the
         value cannot be traced and computed at compile time.
 
-        Since on Ascend, :class:`nan` is treated differently, currently the argument
-        `equal_nan` is not supported on Ascend.
+        Since on Ascend, ``nan`` is treated differently, currently the argument
+        ``equal_nan`` is not supported on Ascend.
 
     Args:
         a1/a2 (Union[int, float, bool, list, tuple, Tensor]): Input arrays.
-        equal_nan (bool): Whether to compare NaN's as equal. Default: ``False`` .
+        equal_nan (bool, optional): Whether to compare NaN's as equal. Default: ``False`` .
 
     Returns:
         Scalar bool tensor, value is `True` if inputs are equal, `False` otherwise.
@@ -869,7 +869,7 @@ def sometrue(a, axis=None, keepdims=False):
 
     Raises:
         TypeError: If input is not array_like or `axis` is not int or tuple of integers or
-            `keepdims` is not integer or `initial` is not scalar.
+            `keepdims` is not bool.
         ValueError: If any axis is out of range or duplicate axes exist.
 
     Supported Platforms:
@@ -900,7 +900,8 @@ def setdiff1d(ar1, ar2, assume_unique=False):
     Args:
         ar1 (Union[int, float, bool, list, tuple, Tensor]): Input tensor.
         ar2 (Union[int, float, bool, list, tuple, Tensor]): Input tensor.
-        assume_unique (bool): If `True`, the input Tensors are assumed to be unique, which can speed up the calculation.
+        assume_unique (bool, optional): If `True`, the input Tensors are assumed to be unique,
+                              which can speed up the calculation.
                               If `True` but `ar1` or `ar2` are not unique,
                               incorrect results and out-of-bounds indices could result.
                               Default: ``False``.

mindspore/numpy/math_ops.py

@@ -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.
@@ -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.
@@ -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)
@@ -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.)
@@ -3497,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``
@@ -3932,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
 
@@ -3978,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:
@@ -4050,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.
@@ -4099,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
@@ -4309,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`.
@@ -4378,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`.
@@ -4421,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])
@@ -4685,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.
@@ -4739,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
 
 
@@ -4795,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.
@@ -4807,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.
@@ -4899,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)``.
 
@@ -4914,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
@@ -5060,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.
@@ -5096,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.
@@ -5128,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:
@@ -5152,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):
@@ -5163,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.
 
@@ -5200,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.
@@ -5230,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.
@@ -5337,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`` .
 
@@ -5472,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:
@@ -5534,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
 
 
@@ -5581,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

mindspore/numpy/utils_const.py

@@ -208,7 +208,7 @@ def _check_shape_aligned(shape1, shape2):
 @_primexpr
 def _tile_size(shape, out_shape, ndim):
     """Returns tile_size such that shape*tile_size = out_shape"""
-    size = [1]*ndim
+    size = [1] * ndim
     for idx, (i, j) in enumerate(zip(shape, out_shape)):
         if i != j:
             size[idx] = j
@@ -441,7 +441,7 @@ def _add_unit_axes(shape, ndim, append=False):
 
 
 @constexpr
-def  _check_element_int(lst):
+def _check_element_int(lst):
     """
     Check whether each element in `lst` is an integer.
     """
@@ -508,7 +508,7 @@ def _iota(dtype, num, increasing=True):
         raise ValueError("zero shape Tensor is not currently supported.")
     if increasing:
         return Tensor(list(range(int(num))), dtype)
-    return Tensor(list(range(int(num)-1, -1, -1)), dtype)
+    return Tensor(list(range(int(num) - 1, -1, -1)), dtype)
 
 
 @constexpr
@@ -520,7 +520,7 @@ def _ceil(number):
 @_primexpr
 def _seq_prod(seq1, seq2):
     """Returns the element-wise product of seq1 and seq2."""
-    return tuple(map(lambda x, y: x*y, seq1, seq2))
+    return tuple(map(lambda x, y: x * y, seq1, seq2))
 
 
 @constexpr