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

mindspore/numpy/array_ops.py

@@ -87,7 +87,7 @@ def squeeze(a, axis=None):
 
     Args:
         a (Tensor): Input tensor array.
-        axis (Union[None, int, list(int), tuple(list)]): The axis(axes) to squeeze,
+        axis (Union[None, int, list(int), tuple(list)], optional): The axis(axes) to squeeze,
             default: ``None`` .
 
     Returns:
@@ -117,7 +117,7 @@ def transpose(a, axes=None):
 
     Args:
         a (Tensor): a tensor to be transposed
-        axes (Union[None, tuple, list]): the axes order, if `axes` is `None`, transpose
+        axes (Union[None, tuple, list], optional): the axes order, if `axes` is `None`, transpose
             the entire tensor. Default: ``None`` .
 
     Returns:
@@ -211,7 +211,7 @@ def rollaxis(x, axis, start=0):
     if start < axis:
         if axis + 1 < ndim:
             new_perm = perm[0:start] + perm[axis:axis + 1] + \
-                perm[start:axis] + perm[axis+1:]
+                perm[start:axis] + perm[axis + 1:]
         else:
             new_perm = perm[0:start] + perm[axis:axis + 1] + perm[start:axis]
     if start > axis:
@@ -219,7 +219,7 @@ def rollaxis(x, axis, start=0):
             new_perm = perm[0:axis] + perm[axis + 1:start] + \
                 perm[axis:axis + 1] + perm[start:]
         else:
-            new_perm = perm[0:axis] + perm[axis+1:start] + \
+            new_perm = perm[0:axis] + perm[axis + 1:start] + \
                 perm[axis:axis + 1]
 
     return F.transpose(x, new_perm)
@@ -401,6 +401,8 @@ def concatenate(arrays, axis=0):
         >>> print(x.shape)
         (1, 2, 4)
     """
+    if arrays is None:
+        _raise_type_error('expect Union[Tensor, tuple(Tensor), list(Tensor)], but got None')
     if isinstance(arrays, Tensor):
         # if only one tensor is provided, it is treated as a tuple along the
         # first dimension. For example, a tensor of shape (3,4,5) will be treated
@@ -447,7 +449,7 @@ def append(arr, values, axis=None):
         values (Tensor): These values are appended to a copy of `arr`. It must be of
             the correct shape (the same shape as `arr`, excluding `axis`). If `axis` is
             not specified, `values` can be any shape and will be flattened before use.
-        axis (None, int, optional): The `axis` along which values are appended. If `axis` is not
+        axis (int, optional): The `axis` along which values are appended. If `axis` is not
             given, both `arr` and `values` are flattened before use, default is ``None``.
 
     Returns:
@@ -669,12 +671,12 @@ def where(condition, x=None, y=None):
 
     Note:
         As nonzero is not supported, both `x` and `y` must be provided Tensor
-    input.
+        input.
 
     Args:
         condition (Tensor): where True, yield `x`, otherwise yield `y`.
-        x (Tensor): Values from which to choose. Default: ``None`` .
-        y (Tensor): Values from which to choose. `x`, `y` and `condition` need
+        x (Tensor, optional): Values from which to choose. Default: ``None`` .
+        y (Tensor, optional): Values from which to choose. `x`, `y` and `condition` need
             to be broadcastable to some shape. Default: ``None`` .
 
     Returns:
@@ -929,7 +931,7 @@ def stack(arrays, axis=0):
         ndim = F.rank(arrays)
         axis = axis % ndim
         axes = F.make_range(ndim)
-        perm = axes[1:axis+1] + (0,) + axes[axis+1:]
+        perm = axes[1:axis + 1] + (0,) + axes[axis + 1:]
         if _is_shape_empty(shape):
             return _empty(mstype.float32, shape[1:axis + 1] + (shape[0],) + shape[axis + 1:])
         return transpose(arrays, perm)
@@ -969,7 +971,7 @@ def unique(x, return_inverse=False):
 
     Args:
         x (Tensor): The input tensor to be processed.
-        return_inverse (bool): If `True`, also return the indices of the unique tensor.
+        return_inverse (bool, optional): If `True`, also return the indices of the unique tensor.
             Default: ``False`` .
 
     Returns:
@@ -1151,9 +1153,9 @@ def moveaxis(a, source, destination):
 
     Args:
         a (Tensor): The array whose axes should be reordered.
-        source (int or sequence of ints): Original positions of the
+        source (int, sequence of ints): Original positions of the
             axes to move. These must be unique.
-        destination (int or sequence of ints): Destination positions
+        destination (int, sequence of ints): Destination positions
             for each of the original axes. These must also be unique.
 
     Returns:
@@ -1203,7 +1205,7 @@ def tile(a, reps):
 
     Args:
         a (Tensor): The input array.
-        reps (int or sequence of ints): The number of repetitions of `a` along
+        reps (int, sequence of ints): The number of repetitions of `a` along
             each axis.
 
     Returns:
@@ -1270,14 +1272,14 @@ def broadcast_to(array, shape):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> x = np.array([1, 2, 3])
         >>> output = np.broadcast_to(x, (3, 3))
         >>> print(output)
         [[1 2 3]
-        [1 2 3]
-        [1 2 3]]
+         [1 2 3]
+         [1 2 3]]
     """
     def _check(shape_a, shape):
         if not _check_can_broadcast_to(shape_a, shape):
@@ -1308,7 +1310,7 @@ def broadcast_arrays(*args):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> x = np.array([[1,2,3]])
         >>> y = np.array([[4],[5]])
@@ -1329,16 +1331,16 @@ def broadcast_arrays(*args):
 
 
 def array_split(x, indices_or_sections, axis=0):
-    """
+    r"""
     Splits a tensor into multiple sub-tensors.
 
     Note:
-        Currently, array_split only supports :class:`mindspore.float32` on ``CPU``.
+        Currently, array_split only supports ``mindspore.float32`` on ``CPU``.
 
     The only difference between ``np.split`` and ``np.array_split`` is that
     ``np.array_split`` allows indices_or_sections to be an integer that does not
     equally divide the axis. For a tensor of length l that should be split into
-    n sections, it returns :math:`l % n` sub-arrays of size :math:`l//n + 1` and
+    n sections, it returns :math:`l \% n` sub-arrays of size :math:`l//n + 1` and
     the rest of size :math:`l//n`.
 
     Args:
@@ -1349,7 +1351,7 @@ def array_split(x, indices_or_sections, axis=0):
             If tuple(int), list(int) or of sorted integers,
             the entries indicate where along axis the array is split.
             For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
-            three sub-tensors :math:`x[:2]`, :math:`x[2:3]`and :math:`x[3:]`.
+            three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
             If an index exceeds the dimension of the array along axis,
             an empty sub-array is returned correspondingly.
         axis (int): The axis along which to split. Default: ``0`` .
@@ -1394,10 +1396,10 @@ def split(x, indices_or_sections, axis=0):
             If tuple(int), list(int) or of sorted integers,
             the entries indicate where along axis the array is split.
             For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
-            three sub-tensors :math:`x[:2]`, :math:`x[2:3]`and :math:`x[3:]`.
+            three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
             If an index exceeds the dimension of the array along axis,
             an empty sub-array is returned correspondingly.
-        axis (int): The axis along which to split. Default: ``0`` .
+        axis (int, optional): The axis along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -1481,7 +1483,7 @@ def _split_sub_tensors(x, indices, axis):
     begin = _list_comprehensions(x.ndim, 0)
     end = _list_comprehensions(x.shape)
     for i, idx in enumerate(indices):
-        begin[axis] = 0 if i == 0 else indices[i-1]
+        begin[axis] = 0 if i == 0 else indices[i - 1]
         end[axis] = idx
         if end[axis] <= begin[axis]:
             _raise_value_error("empty sub-tensor encountered.")
@@ -1504,7 +1506,7 @@ def vsplit(x, indices_or_sections):
             If tuple(int), list(int) or of sorted integers,
             the entries indicate where along axis the array is split.
             For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
-            three sub-tensors :math:`x[:2]`, :math:`x[2:3]`and :math:`x[3:]`.
+            three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
             If an index exceeds the dimension of the array along axis,
             an empty sub-array is returned correspondingly.
 
@@ -1546,7 +1548,7 @@ def hsplit(x, indices_or_sections):
             If tuple(int), list(int) or of sorted integers,
             the entries indicate where along axis the array is split.
             For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
-            three sub-tensors :math:`x[:2]`, :math:`x[2:3]`and :math:`x[3:]`.
+            three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
             If an index exceeds the dimension of the array along axis,
             an empty sub-array is returned correspondingly.
 
@@ -1591,7 +1593,7 @@ def dsplit(x, indices_or_sections):
             If tuple(int), list(int) or of sorted integers,
             the entries indicate where along axis the array is split.
             For example, :math:`[2, 3]` would, for :math:`axis=0`, result in
-            three sub-tensors :math:`x[:2]`, :math:`x[2:3]`and :math:`x[3:]`.
+            three sub-tensors :math:`x[:2]`, :math:`x[2:3]` and :math:`x[3:]`.
             If an index exceeds the dimension of the array along axis,
             an empty sub-array is returned correspondingly.
 
@@ -1645,7 +1647,7 @@ def flip(m, axis=None):
 
     Args:
         m (Tensor): Input array.
-        axis (None or int or tuple of integers, optional): Axis or axes along which
+        axis (Union[int, tuple(int), None], optional): Axis or axes along which
             to flip over. The default, ``axis=None``, will flip over all of the axes
             of the input array. If `axis` is negative it counts from the last to
             the first axis. If `axis` is a tuple of integers, flipping is performed on
@@ -1660,21 +1662,21 @@ def flip(m, axis=None):
     Supported Platforms:
         ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> A = np.arange(8.0).reshape((2,2,2))
         >>> output = np.flip(A)
         >>> print(output)
         [[[7. 6.]
-        [5. 4.]]
-        [[3. 2.]
-        [1. 0.]]]
+          [5. 4.]]
+         [[3. 2.]
+          [1. 0.]]]
         >>> output = np.flip(A, (0, 2))
         >>> print(output)
         [[[5. 4.]
-        [7. 6.]]
-        [[1. 0.]
-        [3. 2.]]]
+          [7. 6.]]
+         [[1. 0.]
+          [3. 2.]]]
     """
     _check_input_tensor(m)
     ndim = F.rank(m)
@@ -1711,15 +1713,15 @@ def flipud(m):
     Supported Platforms:
         ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> A = np.arange(8.0).reshape((2,2,2))
         >>> output = np.flipud(A)
         >>> print(output)
         [[[4. 5.]
-        [6. 7.]]
-        [[0. 1.]
-        [2. 3.]]]
+          [6. 7.]]
+         [[0. 1.]
+          [2. 3.]]]
     """
     return flip(m, 0)
 
@@ -1741,15 +1743,15 @@ def fliplr(m):
     Supported Platforms:
         ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> A = np.arange(8.0).reshape((2,2,2))
         >>> output = np.fliplr(A)
         >>> print(output)
         [[[2. 3.]
-        [0. 1.]]
-        [[6. 7.]
-        [4. 5.]]]
+          [0. 1.]]
+         [[6. 7.]
+          [4. 5.]]]
     """
     return flip(m, 1)
 
@@ -1780,15 +1782,15 @@ def take_along_axis(arr, indices, axis):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> import mindspore.numpy as np
         >>> x = np.arange(12).reshape(3, 4)
         >>> indices = np.arange(3).reshape(1, 3)
         >>> output = np.take_along_axis(x, indices, 1)
         >>> print(output)
         [[ 0  1  2]
-        [ 4  5  6]
-        [ 8  9 10]]
+         [ 4  5  6]
+         [ 8  9 10]]
     """
     _check_input_tensor(arr, indices)
     if axis is None:
@@ -1861,11 +1863,11 @@ def take(a, indices, axis=None, mode='clip'):
         mode ('raise', 'wrap', 'clip', optional): Specifies how out-of-bounds
             indices will behave. Default: ``'clip'`` .
 
-            'raise' – raise an error;
+            'raise' - raise an error;
 
-            'wrap' – wrap around;
+            'wrap' - wrap around;
 
-            'clip' – clip to the range. 'clip' mode means that all indices that are
+            'clip' - clip to the range. 'clip' mode means that all indices that are
             too large are replaced by the index that addresses the last element
             along that axis. Note that this disables indexing with negative numbers.
 
@@ -1902,7 +1904,7 @@ def repeat(a, repeats, axis=None):
 
     Args:
         a (Tensor): Input array.
-        repeats (int or sequence of ints): The number of repetitions for each element.
+        repeats (int, sequence of ints): The number of repetitions for each element.
             `repeats` is broadcasted to fit the shape of the given axis.
         axis (int, optional): The axis along which to repeat values. By default,
             use the flattened input array, and return a flat output array. Default: ``None`` .
@@ -1949,7 +1951,7 @@ def rot90(a, k=1, axes=(0, 1)):
     Args:
         a (Tensor): Input tensor of two or more dimensions.
         k (int): Number of times the tensor is rotated by 90 degrees. Default: ``1`` .
-        axes (Union[tuple(int), list(int)]): The tensor is rotated in the plane
+        axes (Union[tuple(int), list(int)], optional): The tensor is rotated in the plane
             defined by the axes. Default: ``(0, 1)`` .
             Axes must be different and with the shape of `(2,)`.
 
@@ -2137,11 +2139,11 @@ def choose(a, choices, mode='clip'):
         mode ('raise', 'wrap', 'clip', optional): Specifies how indices outside
             ``[0, n-1]`` will be treated:
 
-            'raise' – raise an error;
+            'raise' - raise an error;
 
-            'wrap' – wrap around;
+            'wrap' - wrap around;
 
-            'clip' – clip to the range. 'clip' mode means that all indices that are
+            'clip' - clip to the range. 'clip' mode means that all indices that are
             too large are replaced by the index that addresses the last element
             along that axis. Note that this disables indexing with negative numbers.
 
@@ -2205,7 +2207,7 @@ def size(a, axis=None):
 
     Args:
         a (Union[int, float, bool, list, tuple, Tensor]): Input data.
-        axis (int): Axis along which the elements are counted. Default: ``None``.
+        axis (int, optional): Axis along which the elements are counted. Default: ``None``.
             If None, give the total number of elements.
 
     Returns:
@@ -2349,14 +2351,14 @@ def piecewise(x, condlist, funclist, *args, **kw):
 
     Args:
         x (Union[int, float, bool, list, tuple, Tensor]): The input domain.
-        condlist (Union[bool, list of bool Tensor]): Each boolean array corresponds to a
+        condlist (Union[bool, list[Tensor, bool]]): Each boolean array corresponds to a
             function in `funclist`. Wherever `condlist[i]` is True, `funclist[i](x)` is used as
             the output value. Each boolean array in `condlist` selects a piece of `x`, and
             should therefore be of the same shape as `x`. The length of `condlist` must
             correspond to that of `funclist`. If one extra function is given, i.e. if
             ``len(funclist) == len(condlist) + 1``, then that extra function is the default
             value, used wherever all conditions are false.
-        funclist (Union[list of callables, list of scalars]): Each function is evaluated over
+        funclist (Union[list[callables], list[scalars]]): Each function is evaluated over
             `x` wherever its corresponding condition is True. It should take a 1d array as input
             and give an 1d array or a scalar value as output. If, instead of a callable, a scalar
             is provided then a constant function ``(lambda x: scalar)`` is assumed.
@@ -2416,7 +2418,7 @@ def unravel_index(indices, shape, order='C'):
     Args:
         indices (Union[int, float, bool, list, tuple, Tensor]): An integer array whose elements
             are indices into the flattened version of an array of dimensions shape.
-        shape (tuple of integers): The shape of the array to use for unraveling indices.
+        shape (tuple(int)): The shape of the array to use for unraveling indices.
         order (Union['C', 'F'], optional): Determines whether the indices should be viewed as
             indexing in row-major (C-style) or column-major (Fortran-style) order. Default: ``'C'`` .
 
@@ -2528,7 +2530,7 @@ def argwhere(a):
 
     Returns:
         Tensor. Indices of elements that are non-zero. Indices are grouped by element.
-        This Tensor will have shape :math:`(N, a.ndim)` where N is the number of non-zero items.
+        This Tensor will have shape :math:`(N, a.ndim)` where :math:`N` is the number of non-zero items.
 
     Raises:
         TypeError: If input `a` is not array_like.
@@ -2617,7 +2619,9 @@ def intersect1d(ar1, ar2, assume_unique=False, return_indices=False):
 
     if return_indices:
         ar1_indices = F.masked_select(concat_sort_indices[:-1], mask_res)
-        ar2_indices = F.masked_select(concat_sort_indices[1:], mask_res) - array1.size
+        ar2_indices = F.masked_select(concat_sort_indices[1:], mask_res)
+        if ar2_indices.shape[0] > 0:
+            ar2_indices = ar2_indices - array1.size
         if not assume_unique:
             ar1_indices = ind1.index_select(0, ar1_indices)
             ar2_indices = ind2.index_select(0, ar2_indices)