mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/function/image_func.py

@@ -33,10 +33,10 @@ def bounding_box_decode(anchor_box, deltas, max_shape, means=(0.0, 0.0, 0.0, 0.0
         anchor_box (Tensor): Anchor boxes. The shape of `anchor_box` must be :math:`(n, 4)`.
         deltas (Tensor): Delta of boxes. Which has the same shape with `anchor_box`.
         max_shape (tuple): The max size limit for decoding box calculation.
-        means (tuple, optional): The means of `deltas` calculation. Default: (0.0, 0.0, 0.0, 0.0).
-        stds (tuple, optional): The standard deviations of `deltas` calculation. Default: (1.0, 1.0, 1.0, 1.0).
+        means (tuple, optional): The means of `deltas` calculation. Default: ``(0.0, 0.0, 0.0, 0.0)`` .
+        stds (tuple, optional): The standard deviations of `deltas` calculation. Default: ``(1.0, 1.0, 1.0, 1.0)`` .
         wh_ratio_clip (float, optional): The limit of width and height ratio for decoding box calculation.
-            Default: 0.016.
+            Default: ``0.016`` .
 
     Returns:
         Tensor, decoded boxes. It has the same data type and shape as `anchor_box`.
@@ -50,6 +50,8 @@ def bounding_box_decode(anchor_box, deltas, max_shape, means=(0.0, 0.0, 0.0, 0.0
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> anchor_box = Tensor([[4, 1, 2, 1], [2, 2, 2, 3]], mindspore.float32)
         >>> deltas = Tensor([[3, 1, 2, 2], [1, 2, 1, 4]], mindspore.float32)
         >>> output = ops.bounding_box_decode(anchor_box, deltas, max_shape=(768, 1280), means=(0.0, 0.0, 0.0, 0.0),
@@ -71,8 +73,8 @@ def bounding_box_encode(anchor_box, groundtruth_box, means=(0.0, 0.0, 0.0, 0.0),
     Args:
         anchor_box (Tensor): Anchor boxes. The shape of `anchor_box` must be :math:`(n, 4)`.
         groundtruth_box (Tensor): Ground truth boxes. Which has the same shape with `anchor_box`.
-        means (tuple, optional): Means for encoding bounding boxes calculation. Default: (0.0, 0.0, 0.0, 0.0).
-        stds (tuple, optional): The standard deviations of deltas calculation. Default: (1.0, 1.0, 1.0, 1.0).
+        means (tuple, optional): Means for encoding bounding boxes calculation. Default: ``(0.0, 0.0, 0.0, 0.0)`` .
+        stds (tuple, optional): The standard deviations of deltas calculation. Default: (``1.0, 1.0, 1.0, 1.0)`` .
 
     Returns:
         Tensor, encoded bounding boxes. It has the same data type and shape as input `anchor_box`.
@@ -85,6 +87,8 @@ def bounding_box_encode(anchor_box, groundtruth_box, means=(0.0, 0.0, 0.0, 0.0),
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> anchor_box = Tensor([[2, 2, 2, 3], [2, 2, 2, 3]], mindspore.float32)
         >>> groundtruth_box = Tensor([[1, 2, 1, 4], [1, 2, 1, 4]], mindspore.float32)
         >>> output = ops.bounding_box_encode(anchor_box, groundtruth_box, means=(0.0, 0.0, 0.0, 0.0),
@@ -143,6 +147,9 @@ def check_valid(bboxes, img_metas):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bboxes = Tensor(np.linspace(0, 6, 12).reshape(3, 4), mindspore.float32)
         >>> img_metas = Tensor(np.array([2, 1, 3]), mindspore.float32)
         >>> output = ops.check_valid(bboxes, img_metas)
@@ -171,20 +178,27 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
             If :math:`y1 > y2`, the sampled crop is inverted upside down, the width dimensionis treated
             similarly when :math:`x1 > x2`. If normalized coordinates are not in range :math:`[0, 1]`,
             extrapolated input image values are used instead. Supported data type: float32.
-        box_indices (Tensor): A 1-D Tensor of shape :math:`\text{num\_boxes}` representing the batch
+        box_indices (Tensor): A 1-D Tensor of shape :math:`(num\_boxes)` representing the batch
             index for each box. Supported type: int32.
         crop_size (Tuple[int]): A tuple of two elements: (crop_height, crop_width), representing
             the output size of the cropped and resized images.
             Only positive values are supported. Supported type: int32.
         method (str, optional): An optional string that specifies the sampling method for resizing.
-           It can be "bilinear", "nearest" or "bilinear_v2". The option "bilinear" stands for standard bilinear
-           interpolation algorithm, while "bilinear_v2" may result in better result in some cases.
-           "nearest" is the nearest neighbor interpolation algorithm.
-           Default: "bilinear".
-        extrapolation_value (float, optional): An optional float value used extrapolation, if applicable. Default: 0.0.
+            It can be ``"bilinear"`` , ``"nearest"`` or ``"bilinear_v2"`` . Default: ``"bilinear"`` .
+
+            - ``"nearest"``: Nearest neighbor interpolation. Each output pixel is assigned the value of the
+              nearest input pixel. This method is simple and fast but can result in blocky or pixelated outputs.
+            - ``"bilinear"``: Bilinear interpolation. Each output pixel is a weighted average of the four nearest input
+              pixels, computed using bilinear interpolation. This method produces smoother results compared
+              to nearest neighbor interpolation.
+            - ``"bilinear_v2"``: The optimized variant of
+              ``"bilinear"``, it may achieve better result(higher precision and speed) in some cases.
+
+        extrapolation_value (float, optional): An optional float value used extrapolation, if applicable.
+            Default: ``0.0`` .
 
     Returns:
-        A 4-D tensor of shape :math:`(num_boxes, crop_height, crop_width, depth)` with type(float32).
+        A 4-D tensor of shape :math:`(num\_boxes, crop\_height, crop\_width, depth)` with type(float32).
 
     Raises:
         TypeError: If `image` or `boxes` or `box_indices` is not a Tensor.
@@ -205,6 +219,8 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import ops, Tensor
         >>> BATCH_SIZE = 1
         >>> NUM_BOXES = 5
         >>> IMAGE_HEIGHT = 256

mindspore/ops/function/linalg_func.py

@@ -29,7 +29,64 @@ from ..operations import linalg_ops
 from .._primitive_cache import _get_cache_prim
 
 
-__all__ = ['eig', 'geqrf', 'svd', 'pinv', 'qr']
+__all__ = ['cond', 'eig', 'eigvals', 'geqrf', 'svd', 'pinv', 'qr']
+
+
+def cond(A, p=None):
+    r"""
+    Returns the matrix norm or vector norm of a given tensor.
+
+    `p` is the calculation mode of norm. The following norm modes are supported.
+
+    ==========================  ================================ ==========================================
+    `p`                         norm for matrices                 norm for vectors
+    ==========================  ================================ ==========================================
+    ``None`` (default)          `2`-norm (see below)              `2`-norm (see below)
+    ``'fro'``                   Frobenius norm                    -- not supported --
+    ``'nuc'``                   nuclear norm                      -- not supported --
+    ``inf``                     :math:`max(sum(abs(x), dim=1))`   :math:`max(abs(x))`
+    ``-inf``                    :math:`min(sum(abs(x), dim=1))`   :math:`min(abs(x))`
+    ``0``                       -- not supported --               :math:`sum(x != 0)`
+    ``1``                       :math:`max(sum(abs(x), dim=0))`   as below
+    ``-1``                      :math:`min(sum(abs(x), dim=0))`   as below
+    ``2``                       largest singular value            as below
+    ``-2``                      smallest singular value           as below
+    other ``int`` or ``float``  -- not supported --               :math:`sum(abs(x)^{p})^{(1 / p)}`
+    ==========================  ================================ ==========================================
+
+    Note:
+        Currently, complex numbers are not supported.
+
+    Args:
+        A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)` where * is zero or more batch dimensions.
+        p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. Refer to the table above for
+            behavior. Default: ``None``.
+
+    Returns:
+        Tensor, the result of norm calculation on the specified dimension, `dim`, has the same dtype as `A`.
+
+    Raises:
+        TypeError: If `A` is a vector and `p` is a str.
+        ValueError: If `A` is a matrices and `p` is not in valid mode.
+        ValueError: If `A` is a matrix and `p` is an integer that is not in [1, -1, 2, -2].
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> x = ms.Tensor([[1.0, 0.0, -1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 1.0]])
+        >>> print(ms.ops.cond(x))
+        1.4142
+        >>> print(ms.ops.cond(x, 'fro'))
+        3.1622777
+    """
+    matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
+    if p is None:
+        p = 2
+    norm_a = F.norm(A, p)
+    norm_inv_a = F.norm(matrix_inverse(A), p)
+    return norm_a * norm_inv_a
 
 
 def eig(A):
@@ -41,7 +98,7 @@ def eig(A):
 
     Args:
         A (Tensor): Square matrices of shape :math:`(*, N, N)`,
-          with float32, float64, complex64 or complex128 data type.
+            with float32, float64, complex64 or complex128 data type.
 
     Returns:
         - **eigen_values** (Tensor) - Shape :math:`(*, N)`. eigenvalues of
@@ -58,6 +115,9 @@ def eig(A):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1.0, 0.0], [0.0, 2.0]]), mindspore.float32)
         >>> u, v = ops.eig(input_x)
         >>> print(u)
@@ -69,6 +129,42 @@ def eig(A):
     return _get_cache_prim(P.Eig)(compute_v=True)(A)
 
 
+def eigvals(A):
+    """
+    Computes the eigenvalues of a square matrix(batch square matrices).
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        A (Tensor): Square matrices of shape :math:`(*, N, N)`,
+            with float32, float64, complex64 or complex128 data type.
+
+    Returns:
+        Tensor, with shape :math:`(*, N)`. Returns the eigenvalues of
+        the corresponding matrix, which may not have an order.
+
+    Raises:
+        TypeError: If dtype of `A` is not one of: float64, float32, complex64 or complex128.
+        TypeError: If `A` is not a Tensor.
+        ValueError: If `A` is not a square(batch squares).
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> input_x = Tensor(np.array([[1.0, 0.0], [0.0, 2.0]]), mindspore.float32)
+        >>> u = ops.eigvals(input_x)
+        >>> print(u)
+        [1.+0.j 2.+0.j]
+    """
+    u, _ = _get_cache_prim(P.Eig)(compute_v=False)(A)
+    return u
+
+
 def geqrf(input):
     r"""
     Decomposes a matrix into the product of an orthogonal matrix `Q` and an upper triangular matrix `R`.
@@ -85,8 +181,9 @@ def geqrf(input):
             with dtype of float32, float64, complex64, complex128.
 
     Returns:
-        - **y** (Tensor) - Tensor of shape :math:`(*, m, n)`, has the same dtype as the `x`.
-        - **tau** (Tensor) - Tensor of shape :math:`(*, p)` and :math:`p = min(m, n)`, has the same dtype as the `x`.
+        - **y** (Tensor) - Tensor of shape :math:`(*, m, n)`, has the same dtype as the `input`.
+        - **tau** (Tensor) - Tensor of shape :math:`(*, p)` and :math:`p = min(m, n)`,
+          has the same dtype as the `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
@@ -124,9 +221,9 @@ def svd(input, full_matrices=False, compute_uv=True):
           the supported dtype are float32 and float64.
         full_matrices (bool, optional): If true, compute full-sized :math:`U` and :math:`V`. If false, compute
                                         only the leading P singular vectors, with P is the minimum of M and N.
-                                        Default: False.
+                                        Default: ``False`` .
         compute_uv (bool, optional): If true, compute the left and right singular vectors.
-                                     If false, compute only the singular values. Default: True.
+                                     If false, compute only the singular values. Default: ``True`` .
 
     Returns:
         - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
@@ -178,7 +275,7 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     Batch matrices are supported. If x is a batch matrix, the output has the same batch dimension when
     atol or rtol is float.
     If atol or rtol is a Tensor, its shape must be broadcast to the singular value returned by
-    `x.svd <https://www.mindspore.cn/docs/en/r2.0/api_python/ops/mindspore.ops.svd.html>`_ .
+    `x.svd <https://www.mindspore.cn/docs/en/r2.2/api_python/ops/mindspore.ops.svd.html>`_ .
     If x.shape is :math:`(B, M, N)`, and the shape of atol or rtol is :math:`(K, B)`, the output
     shape is :math:`(K, B, N, M)`.
     When the Hermitian is True, temporary support only real domain, x is treated as a real symmetric, so x is
@@ -188,13 +285,13 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     characteristic value), it is set to zero, and is not used in the computations.
     If rtol is not specified and x is a matrix of dimensions (M, N), then rtol is set to
     be :math:`rtol=max(M, N)*\varepsilon`, :math:`\varepsilon` is the
-    `eps <https://www.mindspore.cn/docs/en/r2.0/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
+    `eps <https://www.mindspore.cn/docs/en/r2.2/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
     If rtol is not specified and atol specifies a value larger than zero, rtol is set to zero.
 
     .. note::
         This function uses
-        `svd <https://www.mindspore.cn/docs/en/r2.0/api_python/ops/mindspore.ops.svd.html>`_ internally,
-        (or `eigh <https://www.mindspore.cn/docs/en/r2.0/api_python/scipy/mindspore.scipy.linalg.eigh.html>`_ ,
+        `svd <https://www.mindspore.cn/docs/en/r2.2/api_python/ops/mindspore.ops.svd.html>`_ internally,
+        (or `eigh <https://www.mindspore.cn/docs/en/r2.2/api_python/scipy/mindspore.scipy.linalg.eigh.html>`_ ,
         when hermitian = True). So it has the same problem as these functions. For details,
         see the warnings in svd() and eigh().
 
@@ -205,9 +302,9 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
             - When hermitian is true, batch dimensions are not supported temporarily.
 
     Keyword args:
-        atol (float, Tensor): absolute tolerance value. Default: None.
-        rtol (float, Tensor): relative tolerance value. Default: None.
-        hermitian (bool): An optional bool. x is assumed to be symmetric if real. Default: False.
+        atol (float, Tensor): absolute tolerance value. Default: ``None`` .
+        rtol (float, Tensor): relative tolerance value. Default: ``None`` .
+        hermitian (bool): An optional bool. x is assumed to be symmetric if real. Default: ``False`` .
 
     Outputs:
         - **output** (Tensor) - same type as input. Shape is :math:`(*, N, M)`, * is zero or more batch dimensions.
@@ -244,31 +341,31 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     else:
         atol = Tensor(0.0)
         if rtol is None:
-            rtol = max(ops.shape(x)) * ops.Eps()(Tensor(1.0, x.dtype))
+            rtol = max(ops.Shape()(x)) * ops.Eps()(Tensor(1.0, x_dtype))
 
-    if not inner.IsInstance()(rtol, mstype.tensor):
-        rtol = Tensor(rtol, mstype.float32)
-    if not inner.IsInstance()(atol, mstype.tensor):
-        atol = Tensor(atol, mstype.float32)
+    if not inner.IsInstance()(rtol, mstype.tensor_type):
+        rtol = F.cast(rtol, mstype.float32)
+    if not inner.IsInstance()(atol, mstype.tensor_type):
+        atol = F.cast(atol, mstype.float32)
 
     if not hermitian:
-        s, u, v = x.svd()
-        max_singular_val = ops.narrow(s, -1, 0, 1)
-        threshold = ops.maximum(atol.expand_dims(-1), rtol.expand_dims(-1) * max_singular_val)
+        s, u, v = linalg_ops.Svd()(x)
+        max_singular_val = _narrow(s, -1, 0, 1)
+        threshold = ops.Maximum()(atol.expand_dims(-1), rtol.expand_dims(-1) * max_singular_val)
         condition = s > threshold
-        reciprocal_s_before = Tensor(ops.Reciprocal()(s)).broadcast_to(condition.shape)
-        zero = ops.Zeros()(condition.shape, s.dtype)
-        s_pseudoinv = ops.select(condition, reciprocal_s_before, zero)
+        reciprocal_s_before = ops.Reciprocal()(s).broadcast_to(condition.shape)
+        zero = F.zeros(condition.shape, s.dtype)
+        s_pseudoinv = ops.Select()(condition, reciprocal_s_before, zero)
         output = ops.matmul(v * s_pseudoinv.expand_dims(-2), _nd_transpose(ops.Conj()(u)))
     else:
-        s, u = _compare_eigh(x)
-        s_abs = s.abs()
+        s, u = linalg_ops.Eigh()(x)
+        s_abs = ops.Abs()(s)
         max_singular_val = ops.amax(s_abs, -1, True)
-        threshold = ops.maximum(atol.expand_dims(-1), rtol.expand_dims(-1) * max_singular_val)
+        threshold = ops.Maximum()(atol.expand_dims(-1), rtol.expand_dims(-1) * max_singular_val)
         condition = s_abs > threshold
-        reciprocal_s_before = Tensor(ops.Reciprocal()(s))
-        zero = ops.Zeros()(condition.shape, s.dtype)
-        s_pseudoinv = ops.select(condition, reciprocal_s_before, zero)
+        reciprocal_s_before = ops.Reciprocal()(s)
+        zero = F.zeros(condition.shape, s.dtype)
+        s_pseudoinv = ops.Select()(condition, reciprocal_s_before, zero)
         output = ops.matmul(u * s_pseudoinv.expand_dims(-2), _nd_transpose(ops.Conj()(u)))
     return output
 
@@ -284,8 +381,8 @@ def qr(input, mode='reduced'):
             float16, float32, float64, complex64 and complex128.
             Define the shape of input as :math:`(..., m, n)`, p as the
             minimum values of m and n.
-        mode (Union['reduced', 'complete'], optional): If `mode` is 'reduced', computing reduce-sized QR decomposition,
-            otherwise, computing the full-sized QR decomposition. Default: 'reduced'.
+        mode (Union['reduced', 'complete'], optional): If `mode` is ``'reduced'`` , computing reduce-sized QR
+            decomposition, otherwise, computing the full-sized QR decomposition. Default: ``'reduced'`` .
 
     Returns:
         - **Q** (Tensor) - The orthonormal matrices of input. If `mode` is 'complete', the shape is :math:`(m, m)`,
@@ -319,13 +416,12 @@ def qr(input, mode='reduced'):
     return qr_(input)
 
 
-def _compare_eigh(x):
-    """
-    compare eigh
-    """
-    from mindspore.scipy.ops import Eigh
-    s, u = Eigh()(x)
-    return s, u
+def _narrow(x, axis, start, length):
+    begins = [0] * x.ndim
+    begins[axis] = start
+    sizes = list(x.shape)
+    sizes[axis] = length
+    return P.Slice()(x, begins, sizes)
 
 
 def _nd_transpose(a):