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

mindspore/numpy/array_ops.py

@@ -88,7 +88,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,
-            default is None.
+            default: ``None`` .
 
     Returns:
         Tensor, with all or a subset of the dimensions of length :math:`1` removed.
@@ -118,7 +118,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
-            the entire tensor. Default is `None`.
+            the entire tensor. Default: ``None`` .
 
     Returns:
         Tensor, the transposed tensor array.
@@ -149,7 +149,7 @@ def rollaxis(x, axis, start=0):
     Args:
         x (Tensor): A Tensor to be transposed.
         axis (int): The axis to be rolled.
-        start (int): Default: 0.
+        start (int): Default: ``0`` .
             If :math:`start <= axis`, the axis is rolled back until it lies in this position (`start`).
             If :math:`start > axis`: the axis is rolled until it lies before this position (`start`).
             If :math:`start < 0`, the start will be normalized as a non-negative number (more details
@@ -210,17 +210,17 @@ def rollaxis(x, axis, start=0):
     new_perm = None
     if start < axis:
         if axis + 1 < ndim:
-            new_perm = perm[0:start] + perm[axis:axis+1] + \
+            new_perm = perm[0:start] + perm[axis:axis + 1] + \
                 perm[start:axis] + perm[axis+1:]
         else:
-            new_perm = perm[0:start] + perm[axis:axis+1] + perm[start:axis]
+            new_perm = perm[0:start] + perm[axis:axis + 1] + perm[start:axis]
     if start > axis:
         if start < ndim:
-            new_perm = perm[0:axis] + perm[axis+1:start] + \
-                perm[axis:axis+1] + perm[start:]
+            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] + \
-                perm[axis:axis+1]
+                perm[axis:axis + 1]
 
     return F.transpose(x, new_perm)
 
@@ -335,9 +335,9 @@ def _move_axes_for_concatenate(arr_shape, axis):
     """
 
     original_axes = tuple(range(len(arr_shape)))
-    new_axes = original_axes[1:axis+1] + (0,) + original_axes[axis+1:]
-    new_shape = arr_shape[1:axis+1] + (arr_shape[0] * arr_shape[axis+1],) + \
-        arr_shape[axis+2:]
+    new_axes = original_axes[1:axis + 1] + (0,) + original_axes[axis + 1:]
+    new_shape = arr_shape[1:axis + 1] + (arr_shape[0] * arr_shape[axis + 1],) + \
+        arr_shape[axis + 2:]
     return new_axes, new_shape
 
 
@@ -375,13 +375,13 @@ def concatenate(arrays, axis=0):
 
     Note:
         To match Numpy behaviour, :math:`axis >= 32` will not cause value error, the
-        `axis` will be treated as :class:`None` instead.
+        `axis` will be treated as ``None`` instead.
 
     Args:
         arrays (Union[Tensor, tuple(Tensor), list(Tensor)]): a tensor or a list
             of tensors to be concatenated.
         axis (Union[None, int], optional): The axis along which the tensors will be joined,
-            if `axis` is :class:`None`, tensors are flattened before use. Default is 0.
+            if `axis` is ``None``, tensors are flattened before use. Default: ``0`` .
 
     Returns:
         A tensor concatenated from a tensor or a list of tensors.
@@ -448,7 +448,7 @@ def append(arr, values, axis=None):
             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
-            given, both `arr` and `values` are flattened before use, default is :class:`None`.
+            given, both `arr` and `values` are flattened before use, default is ``None``.
 
     Returns:
         Tensor, a copy of tensor with values appended to axis.
@@ -673,9 +673,9 @@ def where(condition, x=None, y=None):
 
     Args:
         condition (Tensor): where True, yield `x`, otherwise yield `y`.
-        x (Tensor): Values from which to choose. Defaults to None.
+        x (Tensor): Values from which to choose. Default: ``None`` .
         y (Tensor): Values from which to choose. `x`, `y` and `condition` need
-            to be broadcastable to some shape. Defaults to None.
+            to be broadcastable to some shape. Default: ``None`` .
 
     Returns:
         Tensor or scalar, with elements from `x` where `condition` is True, and
@@ -716,9 +716,6 @@ def where(condition, x=None, y=None):
         x = F.cast(x, mstype.float32)
         y = F.cast(y, mstype.float32)
 
-    if not _check_same_type(F.dtype(condition), mstype.float32):
-        # tiling with bool is not supported on GPU
-        condition = F.cast(condition, mstype.float32)
     dynamic = F.is_sequence_value_unknown(F.shape(condition)) or F.is_sequence_value_unknown(F.shape(x))\
               or F.is_sequence_value_unknown(F.shape(y))
     # As select op currently does not support broadcast, broadcasts input tensors
@@ -732,7 +729,7 @@ def where(condition, x=None, y=None):
         # Get the broadcast shape through broadcast calculation
         add_x_y = x + y
         add_out = condition + F.cast(add_x_y, condition.dtype)
-        shape_out = P.TensorShape()(add_out)
+        shape_out = P.Shape()(add_out)
         condition = ops.broadcast_to(condition, shape_out)
         x = ops.broadcast_to(x, shape_out)
         y = ops.broadcast_to(y, shape_out)
@@ -901,7 +898,7 @@ def stack(arrays, axis=0):
     Args:
         arrays (sequence of Tensor): Each array must have the same shape.
         axis (int, optional): The axis in the result array along which the
-            input arrays are stacked. Default: 0.
+            input arrays are stacked. Default: ``0`` .
 
     Returns:
         Tensor, The stacked array has one more dimension than the input
@@ -934,7 +931,7 @@ def stack(arrays, axis=0):
         axes = F.make_range(ndim)
         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 _empty(mstype.float32, shape[1:axis + 1] + (shape[0],) + shape[axis + 1:])
         return transpose(arrays, perm)
 
     if isinstance(arrays, (list, tuple)):
@@ -942,7 +939,7 @@ def stack(arrays, axis=0):
         ndim = len(shape)
         axis = axis % ndim
         if _is_shape_empty(shape):
-            return _empty(mstype.float32, shape[1:axis+1] + (shape[0],) + shape[axis+1:])
+            return _empty(mstype.float32, shape[1:axis + 1] + (shape[0],) + shape[axis + 1:])
         seq = ()
         for arr in arrays:
             seq += (F.expand_dims(arr, axis),)
@@ -973,7 +970,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.
-            Default: `False`.
+            Default: ``False`` .
 
     Returns:
         Tensor or tuple of Tensors.
@@ -1063,7 +1060,7 @@ def roll(a, shift, axis=None):
             for all given axes.
         axis (Union[int, tuple(int)], optional): Axis or axes along which elements
             are shifted. By default, the array is flattened before shifting, after
-            which the original shape is restored. Default: None.
+            which the original shape is restored. Default: ``None`` .
 
     Returns:
         Tensor, with the same shape as a.
@@ -1359,7 +1356,7 @@ def array_split(x, indices_or_sections, axis=0):
             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): The axis along which to split. Default: ``0`` .
 
     Returns:
         A list of sub-tensors.
@@ -1404,7 +1401,7 @@ def split(x, indices_or_sections, axis=0):
             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): The axis along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -1864,9 +1861,9 @@ def take(a, indices, axis=None, mode='clip'):
         a (Tensor): Source array with shape `(Ni…, M, Nk…)`.
         indices (Tensor): The indices with shape `(Nj...)` of the values to extract.
         axis (int, optional): The axis over which to select values. By default,
-            the flattened input array is used. Defaults to None.
+            the flattened input array is used. Default: ``None`` .
         mode ('raise', 'wrap', 'clip', optional): Specifies how out-of-bounds
-            indices will behave. Defaults to "clip".
+            indices will behave. Default: ``'clip'`` .
 
             'raise' – raise an error;
 
@@ -1912,7 +1909,7 @@ def repeat(a, repeats, axis=None):
         repeats (int or 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. Defaults to None.
+            use the flattened input array, and return a flat output array. Default: ``None`` .
 
     Returns:
         Tensor, output array which has the same shape as `a`, except along the given
@@ -1955,9 +1952,9 @@ 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.
+        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
-            defined by the axes. Default: `(0, 1)`.
+            defined by the axes. Default: ``(0, 1)`` .
             Axes must be different and with the shape of `(2,)`.
 
     Returns:
@@ -2035,7 +2032,7 @@ def select(condlist, choicelist, default=0):
             from which the output elements are taken. It has to be of the same length as
             `condlist`.
         default (scalar, optional): The element inserted in output when all conditions
-            evaluate to `False`. Defaults to 0.
+            evaluate to `False`. Default: ``0`` .
 
     Returns:
         Tensor, the output at position `m` is the `m-th` element of the array in
@@ -2212,7 +2209,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): Axis along which the elements are counted. Default: ``None``.
             If None, give the total number of elements.
 
     Returns:
@@ -2425,7 +2422,7 @@ def unravel_index(indices, shape, order='C'):
             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.
         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. Defaults to "C".
+            indexing in row-major (C-style) or column-major (Fortran-style) order. Default: ``'C'`` .
 
     Returns:
         Tensor, each array in the tuple has the same shape as the indices array.
@@ -2524,3 +2521,105 @@ def apply_over_axes(func, a, axes):
         if res.ndim != a.ndim:
             _raise_value_error("function is not returning a tensor of the correct shape")
     return res
+
+
+def argwhere(a):
+    """
+    Find the indices of Tensor elements that are non-zero, grouped by element.
+
+    Args:
+        a (Union[list, tuple, Tensor]): Input tensor.
+
+    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.
+
+    Raises:
+        TypeError: If input `a` is not array_like.
+        ValueError: If dim of `a` equals to 0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> x = np.array([[[1, 0], [-5, 0]]])
+        >>> np.argwhere(x)
+        Tensor(shape=[2, 3], dtype=Int64, value=[[0, 0, 0], [0, 1, 0]])
+    """
+    a = _to_tensor(a)
+    return F.argwhere(a)
+
+
+def intersect1d(ar1, ar2, assume_unique=False, return_indices=False):
+    """
+    Find the intersection of two Tensors.
+    Return the sorted, unique values that are in both of the input Tensors.
+
+    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.
+                              If `True` but `ar1` or `ar2` are not unique,
+                              incorrect results and out-of-bounds indices could result.
+                              Default: ``False``.
+        return_indices (bool): If `True`, the indices which correspond to the intersection of two Tensors are returned.
+                               The first instance of a value is used if there are multiple.
+                               Default: ``False``.
+
+    Returns:
+        Tensor or tuple of Tensors.
+        If `return_indices` is ``False``, return the intersection tensor, otherwise return tuple of tensors.
+
+    Raises:
+        TypeError: If input `ar1` or `ar2` is not array_like.
+        TypeError: If `assume_unique` or `return_indices` is not bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
+        Tensor(shape=[2], dtype=Int32, value=[1, 3])
+    """
+    def unique_w_ind(arr):
+        array, sort_indices = arr.ravel().sort()
+        array_type = array.dtype
+        cmp_array1 = F.cat((array, Tensor([0], dtype=array_type)))
+        cmp_array2 = F.cat((Tensor([0], dtype=array_type), array))
+        mask = cmp_array1 != cmp_array2
+        mask[0] = True
+        array = F.masked_select(array, mask[:-1])
+        ind = F.masked_select(sort_indices, mask[:-1])
+        return array, ind
+
+    if not isinstance(assume_unique, bool) or not isinstance(return_indices, bool):
+        _raise_type_error("assume_unique or return_indices is not bool type.")
+    ar1, ar2 = _to_tensor(ar1, ar2)
+    ind1 = F.fill(mstype.int32, (ar1.size,), -1)
+    ind2 = F.fill(mstype.int32, (ar2.size,), -1)
+    if not assume_unique:
+        if return_indices:
+            array1, ind1 = unique_w_ind(ar1)
+            array2, ind2 = unique_w_ind(ar2)
+        else:
+            array1 = F.unique(ar1)[0]
+            array2 = F.unique(ar2)[0]
+    else:
+        array1 = ar1.ravel()
+        array2 = ar2.ravel()
+    concat_array = concatenate((array1, array2))
+    concat_array, concat_sort_indices = concat_array.sort()
+
+    mask_res = concat_array[1:] == concat_array[:-1]
+    res = F.masked_select(concat_array[1:], mask_res)
+
+    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
+        if not assume_unique:
+            ar1_indices = ind1.index_select(0, ar1_indices)
+            ar2_indices = ind2.index_select(0, ar2_indices)
+        return res, ar1_indices, ar2_indices
+    return res

mindspore/numpy/logic_ops.py

@@ -38,7 +38,7 @@ def not_equal(x1, x2, dtype=None):
     Args:
         x1 (Tensor): First input tensor to be compared.
         x2 (Tensor): Second input tensor to be compared.
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -76,7 +76,7 @@ def less_equal(x1, x2, dtype=None):
         x1 (Tensor): Input array.
         x2 (Tensor): Input array. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -109,7 +109,7 @@ def less(x1, x2, dtype=None):
         x1 (Tensor): input array.
         x2 (Tensor): Input array. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -141,7 +141,7 @@ def greater_equal(x1, x2, dtype=None):
         x1 (Tensor): Input array.
         x2 (Tensor): Input array. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -173,7 +173,7 @@ def greater(x1, x2, dtype=None):
         x1 (Tensor): Input array.
         x2 (Tensor): Input array. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -205,7 +205,7 @@ def equal(x1, x2, dtype=None):
         x1 (Tensor): Input array.
         x2 (Tensor): Input array. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -238,7 +238,7 @@ def isfinite(x, dtype=None):
 
     Args:
         x (Tensor): Input values.
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -268,7 +268,7 @@ def isnan(x, dtype=None):
 
     Args:
         x (Tensor): Input values.
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -315,7 +315,7 @@ def isinf(x, dtype=None):
 
     Args:
         x (Tensor): Input values.
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -471,7 +471,7 @@ def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
         atol (numbers.Number): The absolute tolerance parameter (see Note).
         equal_nan (bool): 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`.
+            Default: ``False`` .
 
     Returns:
         A ``bool`` tensor of where `a` and `b` are equal within the given tolerance.
@@ -483,6 +483,7 @@ def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore.numpy as np
         >>> a = np.array([0,1,2,float('inf'),float('inf'),float('nan')])
         >>> b = np.array([0,1,-2,float('-inf'),float('inf'),float('nan')])
         >>> print(np.isclose(a, b))
@@ -512,7 +513,7 @@ def in1d(ar1, ar2, invert=False):
             to test each value of `ar1`.
         invert (boolean, optional): If True, the values in the returned array are
             inverted (that is, False where an element of `ar1` is in `ar2` and True
-            otherwise). Default is False.
+            otherwise). Default: ``False`` .
 
     Returns:
        Tensor, with shape `(M,)`. The values ``ar1[in1d]`` are in `ar2`.
@@ -521,6 +522,7 @@ def in1d(ar1, ar2, invert=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore.numpy as np
         >>> test = np.array([0, 1, 2, 5, 0])
         >>> states = [0, 2]
         >>> mask = np.in1d(test, states)
@@ -556,7 +558,7 @@ def isin(element, test_elements, invert=False):
         test_elements (Union[int, float, bool, list, tuple, Tensor]): The values against
             which to test each value of `element`.
         invert (boolean, optional): If True, the values in the returned array are
-            inverted, as if calculating `element` not in `test_elements`. Default is False.
+            inverted, as if calculating `element` not in `test_elements`. Default: ``False`` .
 
     Returns:
        Tensor, has the same shape as `element`. The values ``element[isin]`` are in
@@ -566,6 +568,7 @@ def isin(element, test_elements, invert=False):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore.numpy as np
         >>> element = 2*np.arange(4).reshape((2, 2))
         >>> test_elements = [1, 2, 4, 8]
         >>> mask = np.isin(element, test_elements)
@@ -592,7 +595,7 @@ def logical_not(a, dtype=None):
 
     Args:
         a (Tensor): The input tensor whose dtype is bool.
-        dtype (:class:`mindspore.dtype`, optional): Default: :class:`None`. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None``. Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -628,7 +631,7 @@ def logical_or(x1, x2, dtype=None):
         x1 (Tensor): Input tensor.
         x2 (Tensor): Input tensor. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -662,7 +665,7 @@ def logical_and(x1, x2, dtype=None):
         x1 (Tensor): Input tensor.
         x2 (Tensor): Input tensor. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -696,7 +699,7 @@ def logical_xor(x1, x2, dtype=None):
         x1 (Tensor): Input tensor.
         x2 (Tensor): Input tensor. If ``x1.shape != x2.shape``, they must be
             broadcastable to a common shape (which becomes the shape of the output).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -735,7 +738,7 @@ def array_equal(a1, a2, equal_nan=False):
 
     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): Whether to compare NaN's as equal. Default: ``False`` .
 
     Returns:
         Scalar bool tensor, value is `True` if inputs are equal, `False` otherwise.
@@ -812,7 +815,7 @@ def signbit(x, dtype=None):
 
     Args:
         x (Union[int, float, bool, list, tuple, Tensor]): The input value(s).
-        dtype (:class:`mindspore.dtype`, optional): Defaults to None. Overrides the dtype of the
+        dtype (:class:`mindspore.dtype`, optional): Default: ``None`` . Overrides the dtype of the
             output Tensor.
 
     Returns:
@@ -849,12 +852,12 @@ def sometrue(a, axis=None, keepdims=False):
     Args:
         a (Union[int, float, bool, list, tuple, Tensor]): Input tensor or object that can be converted to an array.
         axis (Union[None, int, tuple(int)]): Axis or axes along which a logical OR reduction is
-            performed. Default: None.
+            performed. Default: ``None`` .
             If None, perform a logical OR over all the dimensions of the input array.
             If negative, it counts from the last to the first axis.
             If tuple of integers, a reduction is performed on multiple axes, instead of a single axis or
             all the axes as before.
-        keepdims (bool): Default: False.
+        keepdims (bool): Default: ``False`` .
             If 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 any method of
@@ -887,3 +890,46 @@ def sometrue(a, axis=None, keepdims=False):
     a = _to_tensor(a)
     keepdims = keepdims not in (0, False)
     return F.not_equal(a, 0).any(axis, keepdims)
+
+
+def setdiff1d(ar1, ar2, assume_unique=False):
+    """
+    Find the set difference of two Tensors.
+    Return the unique values in `ar1` that are not in `ar2`.
+
+    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.
+                              If `True` but `ar1` or `ar2` are not unique,
+                              incorrect results and out-of-bounds indices could result.
+                              Default: ``False``.
+
+    Returns:
+        1D Tensor of values in `ar1` that are not in `ar2`.
+        The result is sorted when `assume_unique` = ``False`` , but otherwise only sorted if the input is sorted.
+
+    Raises:
+        TypeError: If input `ar1` or `ar2` is not array_like.
+        TypeError: If `assume_unique` is not bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore.numpy as np
+        >>> a = np.array([1, 2, 3, 2, 4, 1])
+        >>> b = np.array([3, 4, 5, 6])
+        >>> np.setdiff1d(a, b)
+        Tensor(shape=[2], dtype=Int32, value=[1, 2])
+    """
+    if not isinstance(assume_unique, bool):
+        _raise_type_error("assume_unique is not bool type.")
+    ar1, ar2 = _to_tensor(ar1, ar2)
+    if assume_unique:
+        ar1 = ar1.ravel()
+    else:
+        ar1 = F.unique(ar1)[0].sort()[0]
+        ar2 = F.unique(ar2)[0].sort()[0]
+    mask = in1d(ar1, ar2, invert=True)
+    return F.masked_select(ar1, mask)