mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/function/clip_func.py

@@ -22,8 +22,8 @@ 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
 
 __all__ = [
@@ -34,15 +34,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 +52,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 +229,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:
@@ -300,7 +300,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 +338,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_.

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:
 
@@ -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/r2.3.q1/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/r2.3.q1/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/r2.3.q1/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/r2.3.q1/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/r2.3.q1/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.

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,9 +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.
-            If `p` is one of Union[1, -1, inf, -inf, 'fro', 'nuc'], the function uses
-            :class:`mindspore.ops.MatrixInverse` , therefore, :math:`(*, m, n)` has to be square and ivertible.
+        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``.
 
@@ -86,8 +88,20 @@ def cond(A, p=None):
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
     if p is None:
         p = 2
-    norm_a = F.matrix_norm(A, p)
-    norm_inv_a = F.matrix_norm(matrix_inverse(A), p)
+    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
 
 
@@ -167,49 +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:
-        >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> 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.
@@ -270,16 +241,6 @@ def svd(input, full_matrices=False, compute_uv=True):
     return s
 
 
-def _check_pinv_shape(x):
-    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)}.")
-
-
 def pinv(x, *, atol=None, rtol=None, hermitian=False):
     r"""
     Computes the (Moore-Penrose) pseudo-inverse of a matrix.
@@ -289,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/r2.3.q1/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
@@ -299,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/r2.3.q1/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/r2.3.q1/api_python/ops/mindspore.ops.svd.html>`_ internally,
+        (or `eigh <https://www.mindspore.cn/docs/en/r2.3.q1/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`` .
@@ -340,8 +301,14 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
         [[0.25 0.  ]
          [0.   0.2 ]]
     """
-    _check_pinv_shape(x)
-    x_dtype = _get_cache_prim(P.DType)()(x)
+    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 = dtype_(x)
     _check_input_dtype("x", x_dtype, [mstype.float32, mstype.float64], "pinv")
     _check_attr_dtype("hermitian", hermitian, [bool], "pinv")
 
@@ -431,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):