mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/function/image_func.py

@@ -0,0 +1,270 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Defines image operators with functional form."""
+
+from mindspore.ops import operations as P
+from mindspore.ops.operations import image_ops as IMG
+import mindspore.common.dtype as mstype
+from mindspore.common.tensor import Tensor
+from mindspore._c_expression import Tensor as Tensor_
+from .._primitive_cache import _get_cache_prim
+
+
+def bounding_box_decode(anchor_box, deltas, max_shape, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
+                        wh_ratio_clip=0.016):
+    r"""
+    Decode the bounding box locations, calculate the offset, and convert the offset into a Bbox, which is used to mark
+    the target in the subsequent images, etc.
+
+    Args:
+        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).
+        wh_ratio_clip (float, optional): The limit of width and height ratio for decoding box calculation.
+            Default: 0.016.
+
+    Returns:
+        Tensor, decoded boxes. It has the same data type and shape as `anchor_box`.
+
+    Raises:
+        TypeError: If `means`, `stds` or `max_shape` is not a tuple.
+        TypeError: If `wh_ratio_clip` is not a float.
+        TypeError: If `anchor_box` or `deltas` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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),
+        ...                                  stds=(1.0, 1.0, 1.0, 1.0), wh_ratio_clip=0.016)
+        >>> print(output)
+        [[ 4.1953125  0.         0.         5.1953125]
+         [ 2.140625   0.         3.859375  60.59375  ]]
+    """
+
+    bounding_box_decode_op = _get_cache_prim(P.BoundingBoxDecode)(max_shape, means, stds, wh_ratio_clip)
+    return bounding_box_decode_op(anchor_box, deltas)
+
+
+def bounding_box_encode(anchor_box, groundtruth_box, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0)):
+    r"""
+    Encode the bounding box locations, calculate the offset between the predicted bounding boxes and
+    the real bounding boxes, and the offset will be used as a variable for the loss.
+
+    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).
+
+    Returns:
+        Tensor, encoded bounding boxes. It has the same data type and shape as input `anchor_box`.
+
+    Raises:
+        TypeError: If `means` or `stds` is not a tuple.
+        TypeError: If `anchor_box` or `groundtruth_box` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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),
+        ...                                  stds=(1.0, 1.0, 1.0, 1.0))
+        >>> print(output)
+        [[ -1.  0.25  0.  0.40551758]
+         [ -1.  0.25  0.  0.40551758]]
+    """
+
+    bounding_box_encode_op = _get_cache_prim(P.BoundingBoxEncode)(means, stds)
+    return bounding_box_encode_op(anchor_box, groundtruth_box)
+
+
+def check_valid(bboxes, img_metas):
+    r"""
+    Checks whether the bounding box is in the image.
+
+    `bboxes` contain several sets of bounding boxes, each represented by two abscissa points :math:`(x0, x1)` and
+    two ordinate points :math:`(y0, y1)` .
+    `img_metas` provides information about the original image, including three parameters
+    :math:`(height, width, ratio)` , which specify the valid boundary of the image.
+
+    when the following conditions are met:
+
+    :math:`x0 >= 0`
+
+    :math:`y0 >= 0`
+
+    :math:`x1 <= width * ratio - 1`
+
+    :math:`y1 <= height * ratio - 1`
+
+    the bounding box is considered to be within the image.
+
+    .. warning::
+        The bounding box specified by `bboxes` and the image information specified by `img_metas` need to be valid,
+        i.e.:
+        :math:`x0 <= x1` , :math:`y0 <= y1` , and :math:`(height, width, ratio)` are all positive.
+
+    Args:
+        bboxes (Tensor): Bounding boxes tensor with shape :math:`(N, 4)` . :math:`N` indicates the number of
+            bounding boxes, the value `4` indicates four coordinate points :math:`(x0, y0, x1, y1)` . Data type must
+            be float16 or float32.
+        img_metas (Tensor): Raw image size information with the format of :math:`(height, width, ratio)` , specifying
+            the valid boundary :math:`(height * ratio - 1, width * ratio - 1)` . Data type must be float16 or float32.
+
+    Returns:
+        Tensor, with shape of :math:`(N,)` and dtype of bool, specifying whether the bounding boxes is in the image.
+        `True` indicates valid, while `False` indicates invalid.
+
+    Raises:
+        TypeError: If `bboxes` or `img_metas` is not a Tensor.
+        TypeError: If dtype of `bboxes` or `img_metas` is neither float16 nor float32.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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)
+        >>> print(output)
+        [ True False False]
+    """
+    check_valid_op = _get_cache_prim(P.CheckValid)()
+    return check_valid_op(bboxes, img_metas)
+
+
+def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", extrapolation_value=0.0):
+    r"""
+    Extracts crops from the input image Tensor and resizes them.
+
+    Note:
+        In case that the output shape depends on crop_size, the crop_size must be constant.
+        For now, the backward of the operator only support bilinear method, for other methods, will return 0.
+
+    Args:
+        image (Tensor): A 4-D Tensor representing a batch of images. It has shape
+            :math:`(batch, image\_height, image\_width, depth)`.
+        boxes (Tensor):  A 2-D Tensor with shape :math:`(num\_boxes, 4)` representing the normalized
+            coordinates of the boxes to be cropped. The coordinates are specified in the
+            form :math:`[y1, x1, y2, x2]`, where :math:`(y1, x1)` is the first corner
+            and :math:`(y2, x2)` is the second corner of the box.
+            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
+            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.
+
+    Returns:
+        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.
+        TypeError: If `crop_size` is not a Tuple with two int32 elements.
+        TypeError: If dtype of `boxes` is not float or that of `box_indices` is not int.
+        TypeError: If `method` is not a str.
+        TypeError: If `extrapolation_value` is not a float.
+        ValueError: If the shape rank of `image` is not 4.
+        ValueError: If the shape rank of `boxes` is not 2.
+        ValueError: If the second dim of `boxes` is not 4.
+        ValueError: If the shape rank of `box_indices` is not 1.
+        ValueError: If the first dim of `box_indices` is not equal to that of `boxes`.
+        ValueError: If existing element in `box_indices` is out of range `[0, batch)`.
+        ValueError: If the data of `crop_size` is not positive.
+        ValueError: If `method` is not one of 'bilinear', 'nearest', 'bilinear_v2'.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> BATCH_SIZE = 1
+        >>> NUM_BOXES = 5
+        >>> IMAGE_HEIGHT = 256
+        >>> IMAGE_WIDTH = 256
+        >>> CHANNELS = 3
+        >>> image = np.random.normal(size=[BATCH_SIZE, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS]).astype(np.float32)
+        >>> boxes = np.random.uniform(size=[NUM_BOXES, 4]).astype(np.float32)
+        >>> box_indices = np.random.uniform(size=[NUM_BOXES], low=0, high=BATCH_SIZE).astype(np.int32)
+        >>> crop_size = (24, 24)
+        >>> output = ops.crop_and_resize(Tensor(image), Tensor(boxes), Tensor(box_indices), crop_size)
+        >>> print(output.shape)
+         (5, 24, 24, 3)
+    """
+    if not isinstance(image, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input image must be a tensor")
+    if not isinstance(boxes, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input boxes must be a tensor")
+    if not isinstance(box_indices, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input box_indices must be a tensor")
+    if not isinstance(crop_size, tuple):
+        raise TypeError("For crop_and_resize, the input crop_size must be a tuple, but got {}".format(type(crop_size)))
+    if len(crop_size) != 2:
+        raise ValueError("For crop_and_resize, the crop_size's length must be 2, bot got {}".format(len(crop_size)))
+    if not isinstance(crop_size[0], int) or not isinstance(crop_size[1], int):
+        raise TypeError("For crop_and_resize, the crop_size's value must be int.")
+    if crop_size[0] <= 0 or crop_size[1] <= 0:
+        raise ValueError("For crop_and_resize, the crop_size's value must be positive.")
+
+    image_shape = image.shape
+    if len(image_shape) != 4:
+        raise ValueError(
+            "For crop_and_resize, the input image must be 4D Tensor, but got is {}D".format(len(image_shape)))
+    boxes_dtype = _get_cache_prim(P.DType)()(boxes)
+    if boxes_dtype not in [mstype.float32]:
+        raise TypeError(
+            "For crop_and_resize, the input boxes must be {}, but got {}".format(mstype.float32, boxes_dtype))
+    boxes_shape = boxes.shape
+    if len(boxes_shape) != 2 or boxes_shape[-1] != 4:
+        raise ValueError("For crop_and_resize, the input boxes must be 2D and the second-dim must be 4, "
+                         "but got {}".format(boxes_shape))
+    box_indices_dtype = _get_cache_prim(P.DType)()(box_indices)
+    if box_indices_dtype not in [mstype.int32]:
+        raise TypeError(
+            "For crop_and_resize, the input box_indices must be {}, but got {}".format(mstype.int32, box_indices_dtype))
+    box_indices_shape = box_indices.shape
+    if len(box_indices_shape) != 1:
+        raise ValueError("For crop_and_resize, the input box_indices must be 1D, but got {}".format(box_indices_shape))
+    if boxes_shape[0] != box_indices_shape[0]:
+        raise ValueError("For crop_and_resize, the first dim of input box_indices must be equal to that of input boxes"
+                         ", but got {} vs {}".format(box_indices_shape[0], boxes_shape[0]))
+
+    _crop_and_resize = _get_cache_prim(IMG.CropAndResize)(method, extrapolation_value)
+    return _crop_and_resize(image, boxes, box_indices, crop_size)
+
+
+__all__ = [
+    'bounding_box_decode',
+    'bounding_box_encode',
+    'check_valid',
+    'crop_and_resize'
+]
+
+__all__.sort()

mindspore/ops/function/linalg_func.py

@@ -14,12 +14,102 @@
 # ============================================================================
 
 """Operators for linalg function."""
+from __future__ import absolute_import
+
+import mindspore.ops as ops
+from mindspore.common import dtype as mstype
+from mindspore.common.tensor import Tensor
+from mindspore.ops import operations as P
+from mindspore.ops import functional as F
+from mindspore.ops.operations import _inner_ops as inner
+from mindspore.ops.function.math_func import _check_input_dtype, _check_attr_dtype
+from mindspore._c_expression import Tensor as Tensor_
 
 from ..operations import linalg_ops
 from .._primitive_cache import _get_cache_prim
 
 
-def svd(a, full_matrices=False, compute_uv=True):
+__all__ = ['eig', 'geqrf', 'svd', 'pinv', 'qr']
+
+
+def eig(A):
+    """
+    Computes the eigenvalues and eigenvectors 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:
+        - **eigen_values** (Tensor) - Shape :math:`(*, N)`. eigenvalues of
+          the corresponding matrix. The eigenvalues may not have an order.
+        - **eigen_vectors** (Tensor) - Shape :math:`(*, N, N)`,columns of eigen vectors represent
+        - **normalized** (unit length) eigenvectors of corresponding eigenvalues.
+
+    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:
+        >>> input_x = Tensor(np.array([[1.0, 0.0], [0.0, 2.0]]), mindspore.float32)
+        >>> u, v = ops.eig(input_x)
+        >>> print(u)
+        [1.+0.j 2.+0.j]
+        >>> print(v)
+        [[1.+0.j 0.+0.j]
+         [0.+0.j 1.+0.j]]
+    """
+    return _get_cache_prim(P.Eig)(compute_v=True)(A)
+
+
+def geqrf(input):
+    r"""
+    Decomposes a matrix into the product of an orthogonal matrix `Q` and an upper triangular matrix `R`.
+    The process is called QR decomposition: :math:`A = QR`.
+
+    Both `Q` and `R` matrices are stored in the same output tensor `y`.
+    The elements of `R` are stored on and above the diagonal, whereas elementary reflectors
+    (or Householder vectors) implicitly defining matrix `Q` are stored below the diagonal.
+
+    This function returns two tensors (`y`, `tau`).
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(*, m, n)`, input must be a matrix greater than or equal to 2D,
+            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`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If the dtype of `input` is neither float32, float64, complex64, complex128.
+        ValueError: If `input` dimension is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
+        >>> y, tau = ops.geqrf(input_x)
+        >>> print(y)
+        [[ 2.236068   1.7888544]
+         [-0.236068   1.3416407]]
+        >>> print(tau)
+        [1.8944271 0.       ]
+    """
+    geqrf_ops = _get_cache_prim(P.Geqrf)()
+    return geqrf_ops(input)
+
+
+def svd(input, full_matrices=False, compute_uv=True):
     """
     Computes the singular value decompositions of one or more matrices.
 
@@ -30,7 +120,8 @@ def svd(a, full_matrices=False, compute_uv=True):
         A=U*diag(S)*V^{T}
 
     Args:
-        a (Tensor): Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`.
+        input (Tensor): Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`,
+          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.
@@ -47,7 +138,7 @@ def svd(a, full_matrices=False, compute_uv=True):
     Raises:
         TypeError: If `full_matrices` or `compute_uv` is not the type of bool.
         TypeError: If the rank of input less than 2.
-        TypeError: If the type of input is not one of the following dtype: mstype.float32, mstype.float64.
+        TypeError: If the type of input is not one of the following dtype: float32, float64.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -57,8 +148,8 @@ def svd(a, full_matrices=False, compute_uv=True):
         >>> from mindspore import Tensor, set_context
         >>> from mindspore import ops
         >>> set_context(device_target="CPU")
-        >>> a = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))
-        >>> s, u, v = ops.svd(a, full_matrices=True, compute_uv=True)
+        >>> input = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))
+        >>> s, u, v = ops.svd(input, full_matrices=True, compute_uv=True)
         >>> print(s)
         [7.0652843 1.040081 ]
         >>> print(u)
@@ -72,12 +163,181 @@ def svd(a, full_matrices=False, compute_uv=True):
     svd_ = _get_cache_prim(linalg_ops.Svd)(full_matrices=full_matrices, compute_uv=compute_uv)
 
     if compute_uv:
-        return svd_(a)
+        return svd_(input)
 
-    s, _, _ = svd_(a)
+    s, _, _ = svd_(input)
     return s
 
 
-__all__ = ['svd']
+def pinv(x, *, atol=None, rtol=None, hermitian=False):
+    r"""
+    Computes the (Moore-Penrose) pseudo-inverse of a matrix.
+    This function is computed using SVD. If :math:`x=U*S*V^{T}` ,Than the pseudo-inverse of x is:
+    :math:`x^{+}=V*S^{+}*U^{T}` , :math:`S^{+}` is the reciprocal of each non-zero element on
+    the diagonal of S, and zero remains in place.
+    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>`_ .
+    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
+    not checked internally, and only use the lower triangular part in the computations.
+    When the singular value of x (or the norm of the eigenvalues when hermitian = True) that are below
+    threshold (:math:`max(atol, \sigma \cdot rtol)`, :math:`\sigma` as the largest singular value or
+    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.
+    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>`_ ,
+        when hermitian = True). So it has the same problem as these functions. For details,
+        see the warnings in svd() and eigh().
+
+    Args:
+        x (Tensor): A matrix to be calculated. Only `float32`, `float64` are supported Tensor dtypes.
+            shape is :math:`(*, M, N)`, * is zero or more batch dimensions.
+
+            - 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.
+
+    Outputs:
+        - **output** (Tensor) - same type as input. Shape is :math:`(*, N, M)`, * is zero or more batch dimensions.
+
+    Raises:
+        TypeError: If `hermitian` is not a bool.
+        TypeError: If `x` is not a Tensor.
+        ValueError: If the dimension of `x` is less than 2.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> x = Tensor([[4., 0.], [0., 5.]], mindspore.float32)
+        >>> output = ops.pinv(x)
+        >>> print(output)
+        [[0.25  0. ]
+        [0.  0.2 ]]
+    """
+    if not isinstance(x, (Tensor, Tensor_)):
+        raise TypeError("The input x must be tensor")
+    if x.shape == ():
+        raise TypeError("For pinv, the 0-D input is not supported")
+    x_shape = F.shape(x)
+    if len(x_shape) < 2:
+        raise ValueError("input x should have 2 or more dimensions, " f"but got {len(x_shape)}.")
+    x_dtype = _get_cache_prim(P.DType)()(x)
+    _check_input_dtype("x", x_dtype, [mstype.float32, mstype.float64], "pinv")
+    _check_attr_dtype("hermitian", hermitian, [bool], "pinv")
+
+    if atol is not None:
+        if rtol is None:
+            rtol = Tensor(0.0)
+    else:
+        atol = Tensor(0.0)
+        if rtol is None:
+            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 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)
+        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)
+        output = ops.matmul(v * s_pseudoinv.expand_dims(-2), _nd_transpose(ops.Conj()(u)))
+    else:
+        s, u = _compare_eigh(x)
+        s_abs = s.abs()
+        max_singular_val = ops.amax(s_abs, -1, True)
+        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)
+        output = ops.matmul(u * s_pseudoinv.expand_dims(-2), _nd_transpose(ops.Conj()(u)))
+    return output
+
+
+def qr(input, mode='reduced'):
+    """
+    Returns the QR decomposition of one or more matrices.
+    If `mode` is 'reduced'(the default), compute the P columns of Q where P is minimum of the 2 innermost dimensions of
+    input. If `mode` is 'complete', compute full-sized Q and R.
+
+    Args:
+        input (Tensor): A matrix to be calculated. The matrix must be at least two dimensions, the supported dtype are
+            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'.
+
+    Returns:
+        - **Q** (Tensor) - The orthonormal matrices of input. If `mode` is 'complete', the shape is :math:`(m, m)`,
+          else the shape is :math:`(m, p)`. The dtype of `Q` is same as `input`.
+        - **R** (Tensor) - The upper triangular matrices of input. If `mode` is 'complete', the shape is :math:`(m, n)`,
+          else the shape is :math:`(p, n)`. The dtype of `R` is same as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `mode` is neither 'reduced' nor 'complete'.
+        ValueError: If the dimension of `input` is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input = Tensor(np.array([[20., -31, 7], [4, 270, -90], [-8, 17, -32]]), mstype.float32)
+        >>> Q, R = ops.qr(input)
+        >>> print(Q)
+        [[-0.912871    0.16366126  0.37400758]
+         [-0.18257418 -0.9830709  -0.01544376]
+         [ 0.36514837 -0.08238228  0.92729706]]
+        >>> print(R)
+        [[ -21.908903  -14.788506  -1.6431675]
+        [    0.       -271.9031    92.25824  ]
+        [    0.          0.       -25.665514 ]]
+    """
+    if mode not in ('reduced', 'complete'):
+        raise TypeError(f"For qr, the arg mode must be 'reduced' or 'complete', but got {mode}.")
+    qr_ = _get_cache_prim(P.Qr)(mode == 'complete')
+    return qr_(input)
+
+
+def _compare_eigh(x):
+    """
+    compare eigh
+    """
+    from mindspore.scipy.ops import Eigh
+    s, u = Eigh()(x)
+    return s, u
+
+
+def _nd_transpose(a):
+    """
+    _nd_transpose
+    """
+    dims = a.ndim
+    if dims < 2:
+        raise TypeError("to do _nd_transpose for input a's ndim is not greater or equal to 2d, which is invalid.")
+    axes = ops.make_range(0, dims)
+    axes = axes[:-2] + (axes[-1],) + (axes[-2],)
+    return ops.transpose(a, axes)
+
 
 __all__.sort()