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

mindspore/ops/function/clip_func.py

@@ -22,9 +22,10 @@ from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.common.tensor import Tensor
 from mindspore.common import dtype as mstype
-from mindspore.common.api import jit
 from mindspore.ops.primitive import _primexpr
+from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as Validator
+from mindspore.ops.auto_generate import clamp_tensor, clamp_scalar
 
 __all__ = [
     'clip_by_value',
@@ -34,15 +35,16 @@ __all__ = [
     'clip_by_global_norm',
 ]
 
+apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
+cast_op = P.Cast()
+expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
+get_square_sum = C.MultitypeFuncGraph("get_square_sum")
+greater_equal_ = P.GreaterEqual()
 hyper_map = C.HyperMap()
 max_op = P.Maximum()
 min_op = P.Minimum()
-cast_op = P.Cast()
-scalar2tensor_op = P.ScalarToTensor()
 partial_op = P.Partial()
-expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
-get_square_sum = C.MultitypeFuncGraph("get_square_sum")
-apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
+scalar2tensor_op = P.ScalarToTensor()
 
 
 def _old_norm(norm_type, x):
@@ -51,7 +53,6 @@ def _old_norm(norm_type, x):
     return out
 
 
-@jit
 def _cal_total_norm(x, norm_type):
     if norm_type == float('inf'):
         func = lambda data: data.abs().max()
@@ -229,9 +230,9 @@ def clamp(input, min=None, max=None):
 
         out_i= \left\{
         \begin{array}{align}
-            max & \text{ if } x_i\ge max \\
-            x_i & \text{ if } min \lt x_i \lt max \\
-            min & \text{ if } x_i \le min \\
+            max & \text{ if } input_i\ge max \\
+            input_i & \text{ if } min \lt input_i \lt max \\
+            min & \text{ if } input_i \le min \\
         \end{array}\right.
 
     Note:
@@ -242,18 +243,17 @@ def clamp(input, min=None, max=None):
         - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
 
     Args:
-          input (Union(Tensor, list[Tensor], tuple[Tensor])): Input data, which type is Tensor or a list or tuple of
-            Tensor. Tensors of arbitrary dimensions are supported.
+          input (Tensor): Input data, which type is Tensor. Tensors of arbitrary dimensions are supported.
           min (Union(Tensor, float, int), optional): The minimum value. Default: ``None`` .
           max (Union(Tensor, float, int), optional): The maximum value. Default: ``None`` .
 
     Returns:
-          Union(Tensor, tuple[Tensor], list[Tensor]), a clipped Tensor or a tuple or a list of clipped Tensor.
+          Tensor, a clipped Tensor.
           The data type and shape are the same as input.
 
     Raises:
           ValueError: If both `min` and `max` are None.
-          TypeError: If the type of `input` is not in Tensor or list[Tensor] or tuple[Tensor].
+          TypeError: If the type of `input` is not in Tensor.
           TypeError: If the type of `min` is not in None, Tensor, float or int.
           TypeError: If the type of `max` is not in None, Tensor, float or int.
 
@@ -272,21 +272,10 @@ def clamp(input, min=None, max=None):
         >>> print(output)
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
-        >>> # case 2: the data type of input is list[Tensor]
-        >>> min_value = 5
-        >>> max_value = 20
-        >>> input_x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> input_y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp([input_x,input_y], min_value, max_value)
-        >>> for out in output:
-        ...     print(out)
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
     """
-    return clip_by_value(input, min, max)
-
+    if isinstance(min, Tensor) or isinstance(max, Tensor):
+        return clamp_tensor(input, min, max)
+    return clamp_scalar(input, min, max)
 
 def clip(input, min=None, max=None):
     r"""
@@ -300,7 +289,7 @@ def clip(input, min=None, max=None):
 
 @get_square_sum.register("Tensor")
 def _get_square_sum(x):
-    norm = P.ReduceSum(False)(F.square(x), ())
+    norm = _get_cache_prim(P.ReduceSum)(False)(F.square(x), ())
     norm = expand_dims(F.cast(norm, mstype.float32), 0)
     return norm
 
@@ -338,12 +327,11 @@ class _ClipByGlobalNorm(Cell):
         Validator.check_number("clip_norm", clip_norm, 0.0, Validator.GT, self.cls_name)
         self.clip_norm = Tensor([clip_norm], mstype.float32)
         self.hyper_map = C.HyperMap()
-        self.greater_equal = P.GreaterEqual()
 
     def construct(self, x):
         square_sum = self.hyper_map(get_square_sum, x)
         global_norm = F.sqrt(F.addn(square_sum))
-        cond = self.greater_equal(global_norm, self.clip_norm)
+        cond = greater_equal_(global_norm, self.clip_norm)
         global_norm = F.select(cond, global_norm, self.clip_norm)
         clip_x = self.hyper_map(F.partial(apply_global_norm, self.clip_norm, global_norm), x)
         return clip_x

mindspore/ops/function/debug_func.py

@@ -31,10 +31,7 @@ def print_(*input_x):
         In pynative mode, please use python print function.
         In Ascend platform with graph mode, the bool, int and float would be converted into Tensor to print, and
         str remains unchanged.
-        This function is used for debugging. When too much data is printed at the same time,
-        in order not to affect the main process, the framework may discard some data. If you need to record the
-        data completely, you are recommended to use the `Summary` function, and can check
-        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.2/summary_record.html>`_.
+        This function is used for debugging.
 
     Args:
         input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.
@@ -51,7 +48,7 @@ def print_(*input_x):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.ones([2, 1]).astype(np.int32))
         >>> y = Tensor(np.ones([2, 2]).astype(np.int32))
         >>> result = ops.print_('Print Tensor x and Tensor y:', x, y)

mindspore/ops/function/fft_func.py

@@ -0,0 +1,31 @@
+# Copyright 2023 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 Fast Fourier Transform operators with functional form."""
+from mindspore.ops.auto_generate import fft, fft2, fftn, ifft, ifft2, ifftn, fftshift, ifftshift, rfft, irfft
+
+__all__ = [
+    'fftshift',
+    'ifftshift',
+    'fft',
+    'fft2',
+    'fftn',
+    'ifft',
+    'ifft2',
+    'ifftn',
+    'rfft',
+    'irfft'
+]
+
+__all__.sort()

mindspore/ops/function/grad/grad_func.py

@@ -123,8 +123,8 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
         Function, the gradient function to calculate gradient for the input function or cell.
         For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set ``True`` , gradient function will return
         outputs like `(gradient, out2)` and `out2` does not contribute to the differentiation, otherwise `gradient`.
-        When return_ids is set to ``True`` , The format of the output will be the same with the output of grad when
-        return_ids is set to false, but every gradient in the output will be replaced by a tuple of position id or
+        When return_ids is set to ``True`` , the format of the output will be the same with the output of grad when
+        return_ids is set to ``False``, but every gradient in the output will be replaced by a tuple of position id or
         parameter name and its gradient.
 
     Raises:
@@ -230,7 +230,7 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
     return _get_grad_op(True, True, has_aux, False, return_ids)(fn, weights, grad_position)
 
 
-def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
+def value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
     """
     A wrapper function to generate the function to calculate forward output and gradient for the input function.
 
@@ -253,11 +253,16 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
         has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
             outputs will be returned straightly. It means the `fn` must return more than one outputs in this case.
             Default: ``False`` .
+        return_ids(bool): Whether return the tuple made by gradients and the index to specify which inputs
+            to be differentiated or the name of parameters of the training network that need to calculate the gradient.
+            If ``True`` , the output gradients will be replaced by the tuples made by gradients and the index to specify
+            which inputs to be differentiated or the name of parameters of the training network.
+            Default: ``False`` .
 
     Returns:
         Function, returns the gradient function to calculate forward output and gradient for the input function or cell.
         For example, as for `out1, out2 = fn(*args)` , gradient function will return outputs like
-        `((out1, out2), gradient)` . When `has_aux` is set True, only `out1` contributes to the differentiation.
+        `((out1, out2), gradient)` . When `has_aux` is set to ``True``, only `out1` contributes to the differentiation.
 
     Raises:
         ValueError: If both `grad_position` and `weights` are None.
@@ -346,18 +351,19 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
         raise ValueError("`grad_position` and `weight` can not be None at the same time.")
 
     if grad_position is None:
-        return _get_grad_op(True, False, has_aux, True)(fn, weights)
+        return _get_grad_op(True, False, has_aux, True, return_ids)(fn, weights)
 
     grad_position = _convert_grad_position_type(grad_position)
     if weights is None:
-        return _get_grad_op(False, True, has_aux, True)(fn, None, grad_position)
-    return _get_grad_op(True, True, has_aux, True)(fn, weights, grad_position)
+        return _get_grad_op(False, True, has_aux, True, return_ids)(fn, None, grad_position)
+    return _get_grad_op(True, True, has_aux, True, return_ids)(fn, weights, grad_position)
 
 
 def get_grad(gradients, identifier):
     """
-    When `return_ids` of :func:`mindspore.grad` is set to True, use its return value as gradients. Then find
-    the specific gradient from `gradients` according to `identifier` .
+    When `return_ids` of :func:`mindspore.grad` or :func:`mindspore.grad` is set to ``True`` ,
+    use return value of `mindspore.grad`, or the second return value of `mindspore.grad` as gradients.
+    Then find the specific gradient from `gradients` according to `identifier` .
 
     As for gradient, two typical cases are included:
 
@@ -477,7 +483,7 @@ def jet(fn, primals, series):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> import mindspore as ms
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -587,7 +593,7 @@ def derivative(fn, primals, order):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -654,7 +660,7 @@ def jvp(fn, inputs, v, has_aux=False):
     """
     Compute the jacobian-vector-product of the given network. `jvp` matches
     `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -869,7 +875,7 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
     """
     Compute the vector-jacobian-product of the given network. `vjp` matches
     `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -885,10 +891,11 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
     Returns:
         Forward outputs and function to calculate vjp.
 
-        - **net_output** (Union[Tensor, tuple[Tensor]]) - The output of `fn(inputs)`. Specially, when `has_aux` is set
-          True, `netout` is the first output of `fn(inputs)`.
+        - **net_output** (Union[Tensor, tuple[Tensor]]) - The output of `fn(inputs)`.
+          Specially, when `has_aux` is set to
+          ``True``, `net_output` is the first output of `fn(inputs)`.
         - **vjp_fn** (Function) - To calculate vector-jacobian-product. Its inputs are the vectors whose shape and
-          type should be the same as `netout` .
+          type should be the same as `net_output` .
         - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - When `has_aux` is True, `aux_value` will be returned.
           It means the second to last outputs of `fn(inputs)`. Specially, `aux_value` does not contribute to gradient.
 
@@ -1067,7 +1074,7 @@ def jacfwd(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via forward mode, corresponding to
     `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
@@ -1238,7 +1245,7 @@ def jacrev(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via reverse mode, corresponding to
     `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 
@@ -1369,7 +1376,7 @@ def stop_gradient(value):
     StopGradient is used for eliminating the effect of a value on the gradient, such as truncating
     the gradient propagation from an output of a function.
     For more details, please refer to `Stop Gradient
-    <https://www.mindspore.cn/tutorials/en/r2.2/beginner/autograd.html#stop-gradient>`_.
+    <https://www.mindspore.cn/tutorials/en/master/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.
@@ -1381,7 +1388,7 @@ def stop_gradient(value):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
         >>> def net(x, y):

mindspore/ops/function/image_func.py

@@ -22,6 +22,9 @@ from mindspore.common.tensor import Tensor
 from mindspore._c_expression import Tensor as Tensor_
 from .._primitive_cache import _get_cache_prim
 
+check_valid_ = P.CheckValid()
+dtype_ = P.DType()
+
 
 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):
@@ -156,8 +159,25 @@ def 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)
+    return check_valid_(bboxes, img_metas)
+
+
+def _crop_and_resize_check(image, boxes, box_indices, crop_size):
+    """Check crop and resize input"""
+    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.")
 
 
 def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", extrapolation_value=0.0):
@@ -166,7 +186,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
 
     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.
+        For now, the backward of the operator only supports bilinear method, for other methods, will return 0.
 
     Args:
         image (Tensor): A 4-D Tensor representing a batch of images. It has shape
@@ -203,7 +223,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
     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 dtype of `boxes` is not float or that of `box_indices` is not int32.
         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.
@@ -234,26 +254,12 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
         >>> 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.")
-
+    _crop_and_resize_check(image, boxes, box_indices, crop_size)
     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)
+    boxes_dtype = 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))
@@ -261,7 +267,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
     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)
+    box_indices_dtype = 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))

mindspore/ops/function/linalg_func.py

@@ -24,13 +24,16 @@ 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 mindspore.ops.auto_generate import geqrf
 
 from ..operations import linalg_ops
 from .._primitive_cache import _get_cache_prim
 
-
 __all__ = ['cond', 'eig', 'eigvals', 'geqrf', 'svd', 'pinv', 'qr']
 
+dtype_ = P.DType()
+geqrf_ = P.Geqrf()
+slice_ = P.Slice()
 
 def cond(A, p=None):
     r"""
@@ -58,7 +61,8 @@ def cond(A, p=None):
         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.
+        A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)`
+            where :math:`*` 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``.
 
@@ -84,6 +88,18 @@ def cond(A, p=None):
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
     if p is None:
         p = 2
+    if A.dim() >= 3:
+        shape_ori = A.shape[0:-2]
+        A_flatten = ops.flatten(A, start_dim=0, end_dim=-3)
+        out = []
+        for i in range(A_flatten.shape[0]):
+            norm_a = F.norm(A_flatten[i], p)
+            norm_inv_a = F.norm(matrix_inverse(A_flatten[i]), p)
+            cond_i = ops.fill(mstype.float32, (1, 1), norm_a * norm_inv_a)
+            out.append(cond_i)
+        out_stacked = ops.hstack(out)
+        output = ops.reshape(out_stacked, shape_ori)
+        return output
     norm_a = F.norm(A, p)
     norm_inv_a = F.norm(matrix_inverse(A), p)
     return norm_a * norm_inv_a
@@ -165,47 +181,6 @@ def eigvals(A):
     return u
 
 
-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 `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.
-        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.
@@ -275,7 +250,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.2/api_python/ops/mindspore.ops.svd.html>`_ .
+    `x.svd <https://www.mindspore.cn/docs/en/master/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
@@ -285,21 +260,21 @@ 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.2/api_python/ops/mindspore.ops.Eps.html>`_ value of x.dtype.
+    `eps <https://www.mindspore.cn/docs/en/master/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.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,
+        `svd <https://www.mindspore.cn/docs/en/master/api_python/ops/mindspore.ops.svd.html>`_ internally,
+        (or `eigh <https://www.mindspore.cn/docs/en/master/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.
+            - When `hermitian` is ``True``, batch dimensions are not supported temporarily.
 
     Keyword args:
         atol (float, Tensor): absolute tolerance value. Default: ``None`` .
@@ -318,11 +293,13 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
         ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[4., 0.], [0., 5.]], mindspore.float32)
         >>> output = ops.pinv(x)
         >>> print(output)
-        [[0.25  0. ]
-        [0.  0.2 ]]
+        [[0.25 0.  ]
+         [0.   0.2 ]]
     """
     if not isinstance(x, (Tensor, Tensor_)):
         raise TypeError("The input x must be tensor")
@@ -331,7 +308,7 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
     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)
+    x_dtype = dtype_(x)
     _check_input_dtype("x", x_dtype, [mstype.float32, mstype.float64], "pinv")
     _check_attr_dtype("hermitian", hermitian, [bool], "pinv")
 
@@ -421,7 +398,7 @@ def _narrow(x, axis, start, length):
     begins[axis] = start
     sizes = list(x.shape)
     sizes[axis] = length
-    return P.Slice()(x, begins, sizes)
+    return slice_(x, begins, sizes)
 
 
 def _nd_transpose(a):