mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/ops/function/grad/grad_func.py

@@ -22,12 +22,13 @@ from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 from mindspore.nn.cell import Cell
 from mindspore.nn.grad.cell_grad import _LinearizeInner
-from mindspore.ops.operations.other_ops import stop_gradient_
+from mindspore.ops.operations.other_ops import stop_gradient_op
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.ops.function.array_func import ones, expand_dims, size, reshape, broadcast_to, transpose, zeros
 from mindspore.ops.composite import _Vmap, _Grad, _TaylorOperation, GradOperation
 from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
+from mindspore.ops.auto_generate.gen_ops_prim import inplace_stop_gradient_op
 
 cast = P.Cast()
 dtype = P.DType()
@@ -103,11 +104,13 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
-        grad_position (Union[NoneType, int, tuple[int]]): Index to specify which inputs to be differentiated.
-            If int, get the gradient with respect to single input.
-            If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
-            If None, none derivative of any input will be figured out, and in this case, `weights` is required.
-            Default: ``0`` .
+        grad_position (Union[NoneType, int, tuple[int]]):
+            Index to specify which inputs to be differentiated. Default: ``0`` .
+
+            - If int, get the gradient with respect to single input.
+            - If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
+            - If None, none derivative of any input will be figured out, and in this case, `weights` is required.
+
         weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
             calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
             Default: ``None`` .
@@ -237,36 +240,43 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=
 
     As for gradient, three typical cases are included:
 
-    1. gradient with respect to inputs. In this case, `grad_position` is not None while `weights` is None.
-    2. gradient with respect to weights. In this case, `grad_position` is None while `weights` is not None.
-    3. gradient with respect to inputs and weights. In this case, `grad_position` and `weights` are not None.
+    1. gradient with respect to inputs. In this case, `grad_position` is not None while `weights` is ``None``.
+    2. gradient with respect to weights. In this case, `grad_position` is None while `weights` is not ``None``.
+    3. gradient with respect to inputs and weights. In this case, `grad_position` and `weights` are not ``None``.
 
     Args:
         fn (Union[Cell, Function]): Function to do GradOperation.
-        grad_position (Union[NoneType, int, tuple[int]]): Index to specify which inputs to be differentiated.
-            If int, get the gradient with respect to single input.
-            If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
-            If None, none derivative of any input will be solved, and in this case, `weights` is required.
-            Default: ``0`` .
-        weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
+        grad_position (Union[NoneType, int, tuple[int]], optional): Index to specify which inputs
+            to be differentiated. Default: ``0`` .
+
+            - If int, get the gradient with respect to single input.
+            - If tuple, get the gradients with respect to selected inputs. `grad_position` begins with 0.
+            - If None, none derivative of any input will be solved, and in this case, `weights` is required.
+
+        weights (Union[ParameterTuple, Parameter, list[Parameter]], optional):
+            The parameters of the training network that need to
             calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
             Default: ``None`` .
-        has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
+        has_aux (bool, optional): 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.
+        return_ids(bool, optional): Whether the returned derivation function contains
+            `grad_position` or `weights` information. If ``True``,
+            all gradient values in the returned derivation function will be replaced
+            with: [gradient, grad_position] or [gradient, weights].
             Default: ``False`` .
 
     Returns:
-        Function, returns the gradient function to calculate forward output and gradient for the input function or cell.
+        Function, the derivative function used to compute the gradient of a given function.
         For example, as for `out1, out2 = fn(*args)` , gradient function will return outputs like
-        `((out1, out2), gradient)` . When `has_aux` is set to ``True``, only `out1` contributes to the differentiation.
+        `((out1, out2), gradient)` . When `has_aux` is set to ``True``,
+        only `out1` contributes to the differentiation. If `return_ids` is ``True``,
+        all gradient values in the returned derivation function will be replaced
+        with: [gradient, grad_position] or [gradient, weights].
 
     Raises:
-        ValueError: If both `grad_position` and `weights` are None.
+        ValueError: If both `grad_position` and `weights` are ``None``.
         TypeError: If type of Args does not belong to required ones.
 
     Supported Platforms:
@@ -378,10 +388,10 @@ def get_grad(gradients, identifier):
             :func:`mindspore.grad`.
 
     Returns:
-        The gradient of the tensor on the position or in the parameter that specified by the `identifier`.
+        The Tensor gradient value corresponding to the `identifier`.
 
     Raises:
-        RuntimeError: If gradient is not found.
+        RuntimeError: If gradient value corresponding to the `identifier` is not found.
         TypeError: If type of Args does not belong to required ones.
 
     Supported Platforms:
@@ -457,49 +467,42 @@ def jet(fn, primals, series):
     while the other to 0, which is like the derivative of origin input with respect to itself.
 
     Note:
-        If `primals` is Tensor of int type, it will be converted to Tensor of float type.
+        If `primals` is tensor of int type, it will be converted to Tensor of float type.
 
     Args:
         fn (Union[Cell, function]): Function to do TaylorOperation.
         primals (Union[Tensor, tuple[Tensor]]): The inputs to `fn`.
-        series (Union[Tensor, tuple[Tensor]]): If tuple, the length and type of series should be the same as inputs.
-            For each Tensor, the length of first dimension `i` represents the `1` to `i+1`-th order of derivative of
-            output with respect to the inputs will be figured out.
+        series (Union[Tensor, tuple[Tensor]]): The original 1st to nth order derivatives of the input.
+            The index `i` of the zeroth dimension of the tensor corresponds to the `i+1` -th order derivative of the
+            output with respect to the input.
 
     Returns:
-        Tuple, tuple of out_primals and out_series.
+        Tuple(out_primals, out_series)
 
         - **out_primals** (Union[Tensor, list[Tensor]]) - The output of `fn(primals)`.
-        - **out_series** (Union[Tensor, list[Tensor]]) - The `1` to `i+1`-th order of derivative of output with respect
+        - **out_series** (Union[Tensor, list[Tensor]]) - The `1` to `i+1` -th order of derivative of output with respect
           to the inputs.
 
-    Raises:
-        TypeError: If `primals` is not a tensor or tuple of tensors.
-        TypeError: If type of `primals` is not the same as type of `series`.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> import mindspore.nn as nn
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> import mindspore
+        >>> from mindspore import nn
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super().__init__()
-        ...         self.sin = ops.Sin()
-        ...         self.exp = ops.Exp()
+        ...         self.sin = mindspore.ops.Sin()
+        ...         self.exp = mindspore.ops.Exp()
         ...     def construct(self, x):
         ...         out1 = self.sin(x)
         ...         out2 = self.exp(out1)
         ...         return out2
-        >>> primals = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
-        >>> series = Tensor(np.array([[[1, 1], [1, 1]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]]).astype(np.float32))
+        >>> primals = mindspore.tensor([[1, 2], [3, 4]], mindspore.float32)
+        >>> series = mindspore.tensor([[[1, 1], [1, 1]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], mindspore.float32)
         >>> net = Net()
-        >>> out_primals, out_series = ops.jet(net, primals, series)
+        >>> out_primals, out_series = mindspore.ops.jet(net, primals, series)
         >>> print(out_primals, out_series)
         [[2.319777  2.4825778]
          [1.1515628 0.4691642]] [[[ 1.2533808  -1.0331168 ]
@@ -567,49 +570,41 @@ def derivative(fn, primals, order):
     input first order derivative is set to 1, while the other to 0.
 
     Note:
-        If `primals` is Tensor of int type, it will be converted to Tensor of float type.
+        If `primals` is tensor of int type, it will be converted to tensor of float type.
 
     Args:
         fn (Union[Cell, function]): Function to do TaylorOperation.
         primals (Union[Tensor, tuple[Tensor]]): The inputs to `fn`.
-        order (int): For each Tensor, the `order`-th order of derivative of output with respect to the inputs will be
-            figured out.
+        order (int): The order of differentiation.
 
     Returns:
-        Tuple, tuple of out_primals and out_series.
+        Tuple(out_primals, out_series)
 
         - **out_primals** (Union[Tensor, list[Tensor]]) - The output of `fn(primals)`.
         - **out_series** (Union[Tensor, list[Tensor]]) - The `order`-th order of derivative of output with respect
           to the inputs.
 
-    Raises:
-        TypeError: If `primals` is not a tensor or tuple of tensors.
-        TypeError: If `order` is not int.
-        ValueError: If `order` is less than 1.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import ops
-        >>> from mindspore import Tensor
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> import mindspore
+        >>> from mindspore import nn
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super().__init__()
-        ...         self.sin = ops.Sin()
-        ...         self.exp = ops.Exp()
+        ...         self.sin = mindspore.ops.Sin()
+        ...         self.exp = mindspore.ops.Exp()
         ...     def construct(self, x):
         ...         out1 = self.sin(x)
         ...         out2 = self.exp(out1)
         ...         return out2
-        >>> primals = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
+        >>>
+        >>> primals = mindspore.tensor([[1, 2], [3, 4]], mindspore.float32)
         >>> order = 3
         >>> net = Net()
-        >>> out_primals, out_series = ops.derivative(net, primals, order)
+        >>> out_primals, out_series = mindspore.ops.derivative(net, primals, order)
         >>> print(out_primals, out_series)
         [[2.319777  2.4825778]
          [1.1515628 0.4691642]] [[-4.0515366   3.6724353 ]
@@ -677,7 +672,7 @@ def jvp(fn, inputs, v, has_aux=False):
         - **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)` .
         - **jvp** (Union[Tensor, tuple[Tensor]]) - The result of jacobian-vector-product.
-        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - When `has_aux` is ``True`` , `aux_value` will be
+        - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - Only 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.
 
@@ -841,7 +836,7 @@ def linearize(fn, inputs):
     """
     linearize_inner = _LinearizeInner()
 
-    @jit(hash_args=fn)
+    @jit
     def _wrap_container(*arg):
         args = arg[1:-1]
         vectors = arg[-1]
@@ -882,10 +877,12 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
             Tensors.
         inputs (Union[Tensor, tuple[Tensor], list[Tensor]]): The inputs to `fn` .
-        weights (Union[ParameterTuple, Parameter, list[Parameter]]): The parameters of the training network that need to
+        weights (Union[ParameterTuple, Parameter, list[Parameter]], optional):
+            The parameters of the training network that need to
             calculate the gradient. `weights` can be got through `weights = net.trainable_params()` .
             Default: ``None`` .
-        has_aux (bool): If True, only the first output of `fn` contributes the gradient of `fn`, while the other outputs
+        has_aux (bool, optional): 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``.
 
@@ -1388,6 +1385,41 @@ def stop_gradient(value):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
+    Examples:
+        >>> import mindspore
+        >>> def f1(x):
+        ...     return x ** 2
+        >>> x = 3.0
+        >>> f1(x)
+        9.0
+        >>> mindspore.ops.grad(f1)(mindspore.tensor(x))
+        Tensor(shape=[], dtype=Float32, value= 6)
+        >>>
+        >>> # The same function with stop_gradient, return a zero gradient because x is effectively treated as a constant.
+        >>> def f2(x):
+        ...     return mindspore.ops.stop_gradient(x) ** 2
+        >>> f2(x)
+        9.0
+        >>> mindspore.ops.grad(f2)(mindspore.tensor(x))
+        Tensor(shape=[], dtype=Float32, value= 0)
+    """
+    return stop_gradient_op(value)
+
+
+def stop_gradient_(input):
+    """
+    StopGradient inplace
+
+    Args:
+        input (Tensor): input tensor
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        RuntimeError: If `input` is a view tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
     Examples:
         >>> from mindspore import ops
         >>> from mindspore import Tensor
@@ -1395,7 +1427,7 @@ def stop_gradient(value):
         >>> def net(x, y):
         ...     out1 = ops.MatMul()(x, y)
         ...     out2 = ops.MatMul()(x, y)
-        ...     out2 = ops.stop_gradient(out2)
+        ...     ops.stop_gradient_(out2)
         ...     return out1, out2
         ...
         >>> x = Tensor([[0.5, 0.6, 0.4], [1.2, 1.3, 1.1]], dtype=mstype.float32)
@@ -1406,7 +1438,7 @@ def stop_gradient(value):
         [[1.4100001 1.6       6.5999994]
          [1.4100001 1.6       6.5999994]]
     """
-    return stop_gradient_(value)
+    inplace_stop_gradient_op(input)
 
 
 __all__ = [
@@ -1420,6 +1452,7 @@ __all__ = [
     'vjp',
     'linearize',
     'stop_gradient',
+    'stop_gradient_',
     'get_grad'
 ]
 __all__.sort()

mindspore/ops/function/image_func.py

@@ -19,7 +19,7 @@ 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 mindspore._c_expression import TensorPy as Tensor_
 from .._primitive_cache import _get_cache_prim
 
 check_valid_ = P.CheckValid()
@@ -252,7 +252,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
         >>> 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)
+        (5, 24, 24, 3)
     """
     _crop_and_resize_check(image, boxes, box_indices, crop_size)
     image_shape = image.shape

mindspore/ops/function/linalg_func.py

@@ -23,7 +23,7 @@ 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 mindspore._c_expression import TensorPy as Tensor_
 from mindspore.ops.auto_generate import geqrf
 
 from ..operations import linalg_ops
@@ -37,7 +37,7 @@ slice_ = P.Slice()
 
 def cond(A, p=None):
     r"""
-    Returns the matrix norm or vector norm of a given tensor.
+    Return the matrix norm or vector norm of a given tensor.
 
     `p` is the calculation mode of norm. The following norm modes are supported.
 
@@ -61,28 +61,22 @@ def cond(A, p=None):
         Currently, complex numbers are not supported.
 
     Args:
-        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``.
+        A (Tensor): The input tensor which 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].
+        Tensor
 
     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))
+        >>> import mindspore
+        >>> x = mindspore.tensor([[1.0, 0.0, -1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 1.0]])
+        >>> print(mindspore.ops.cond(x))
         1.4142
-        >>> print(ms.ops.cond(x, 'fro'))
+        >>> print(mindspore.ops.cond(x, 'fro'))
         3.1622777
     """
     matrix_inverse = _get_cache_prim(P.MatrixInverse)(adjoint=False)
@@ -119,7 +113,7 @@ def eig(A):
     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
+        - **eigen_vectors** (Tensor) - Shape :math:`(*, N, N)`, columns of eigen vectors represent
         - **normalized** (unit length) eigenvectors of corresponding eigenvalues.
 
     Raises:
@@ -147,35 +141,24 @@ def eig(A):
 
 def eigvals(A):
     """
-    Computes the eigenvalues of a square matrix(batch square matrices).
+    Compute the eigenvalues of a square matrix.
 
     .. 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.
+        A (Tensor): Square matrices with shape :math:`(*, N, N)` .
 
     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).
+        Tensor
 
     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]
+        >>> mindspore.ops.eigvals(mindspore.tensor([[1.0, 0.0], [0.0, 2.0]]))
+        Tensor(shape=[2], dtype=Complex64, value= [1+0j, 2+0j])
     """
     u, _ = _get_cache_prim(P.Eig)(compute_v=False)(A)
     return u
@@ -192,45 +175,39 @@ def svd(input, full_matrices=False, compute_uv=True):
         A=U*diag(S)*V^{T}
 
     Args:
-        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
+        input (Tensor): The input tensor, shape is :math:`(*, M, N)`.
+        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`` .
-        compute_uv (bool, optional): If true, compute the left and right singular vectors.
-                                     If false, compute only the singular values. Default: ``True`` .
+                                        Default ``False`` .
+        compute_uv (bool, optional): If ``True`` , compute the left and right singular vectors.
+                                     If ``False``, compute only the singular values. Default ``True`` .
 
     Returns:
-        - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
-        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is False, u will not be returned.
-          The shape is :math:`(*, M, P)`. If `full_matrices` is True, the shape will be :math:`(*, M, M)`.
-        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is False, v will not be returned.
-          The shape is :math:`(*, N, P)`. If `full_matrices` is True, the shape will be :math:`(*, N, N)`.
+        If compute_uv is ``True`` , a tuple( `s` , `u` , `v` ) of tensors will be returned. Otherwise, only
+        a single tensor -> `s` will be returned.
 
-    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: float32, float64.
+        - `s` is the singular value tensor. The shape is :math:`(*, P)`.
+        - `u` is the left singular tensor. If `compute_uv` is ``False`` , `u` will not be returned.
+          The shape is :math:`(*, M, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, M, M)`.
+        - `v` is the right singular tensor. If `compute_uv` is ``False`` , `v` will not be returned.
+          The shape is :math:`(*, N, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, N, N)`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, set_context
-        >>> from mindspore import ops
-        >>> set_context(device_target="CPU")
-        >>> 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)
+        >>> import mindspore
+        >>> input = mindspore.tensor([[1, 2], [-4, -5], [2, 1]], mindspore.float32)
+        >>> s, u, v = mindspore.ops.svd(input, full_matrices=True, compute_uv=True)
         >>> print(s)
         [7.0652843 1.040081 ]
         >>> print(u)
-        [[ 0.30821905 -0.48819482 0.81649697]
-         [-0.90613353  0.11070572 0.40824813]
-         [ 0.2896955   0.8656849  0.4082479 ]]
+        [[ 0.30821905 -0.48819482  0.81649697]
+         [-0.90613353  0.11070572  0.40824813]
+         [ 0.2896955   0.8656849   0.4082479 ]]
         >>> print(v)
-        [[ 0.63863593 0.769509  ]
-         [ 0.769509  -0.63863593]]
+        [[ 0.63863593  0.769509  ]
+         [ 0.769509   -0.63863593]]
     """
     svd_ = _get_cache_prim(linalg_ops.Svd)(full_matrices=full_matrices, compute_uv=compute_uv)
 
@@ -244,6 +221,7 @@ def svd(input, full_matrices=False, compute_uv=True):
 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.
@@ -271,32 +249,24 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
         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.
+        x (Tensor): The input tensor whose 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`` .
+        atol (float, Tensor): The absolute tolerance value. Default ``None`` .
+        rtol (float, Tensor): The relative tolerance value. Default ``None`` .
+        hermitian (bool): Whether `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.
+        A tensor whose shape is :math:`(*, N, M)`, * is zero or more batch dimensions.
 
     Supported Platforms:
         ``CPU``
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor([[4., 0.], [0., 5.]], mindspore.float32)
-        >>> output = ops.pinv(x)
+        >>> x = mindspore.tensor([[4., 0.], [0., 5.]], mindspore.float32)
+        >>> output = mindspore.ops.pinv(x)
         >>> print(output)
         [[0.25 0.  ]
          [0.   0.2 ]]
@@ -327,8 +297,7 @@ def pinv(x, *, atol=None, rtol=None, hermitian=False):
 
     if not hermitian:
         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)
+        threshold = ops.Maximum()(atol.expand_dims(-1), rtol.expand_dims(-1) * _narrow(s, -1, 0, 1))
         condition = s > threshold
         reciprocal_s_before = ops.Reciprocal()(s).broadcast_to(condition.shape)
         zero = F.zeros(condition.shape, s.dtype)