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

mindspore/scipy/linalg.py

@@ -14,7 +14,6 @@
 # ============================================================================
 """Linear algebra submodule"""
 from __future__ import absolute_import
-from .ops import Eigh
 from .ops import LU
 from .ops import SolveTriangular
 from .utils import _nd_transpose, _value_check, _type_check, _dtype_check, _mstype_check, _square_check, _solve_check
@@ -23,6 +22,7 @@ from .. import numpy as mnp
 from .. import ops
 from ..common import dtype as mstype
 from ..ops.operations.math_ops import Cholesky
+from ..ops.operations.linalg_ops import Eigh
 from ..ops import functional as F
 from ..ops import operations as P
 
@@ -60,7 +60,7 @@ def block_diag(*arrs):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import block_diag
         >>> A = Tensor(onp.array([[1, 0], [0, 1]]))
         >>> B = Tensor(onp.array([[3, 4, 5], [6, 7, 8]]))
@@ -107,10 +107,10 @@ def inv(a, overwrite_a=False, check_finite=True):
 
     Args:
         a (Tensor): Square matrix to be inverted.
-        overwrite_a (bool, optional): Discard data in `a` (may improve performance). Default: False.
+        overwrite_a (bool, optional): Discard data in `a` (may improve performance). Default: ``False`` .
         check_finite (bool, optional): Whether to check that the input matrix contains only finite numbers.
             Disabling may give a performance gain, but may result in problems (crashes, non-termination)
-            if the inputs do contain infinities or NaNs. Default: True.
+            if the inputs do contain infinities or NaNs. Default: ``True`` .
 
     Returns:
         Tensor, inverse of the matrix `a`.
@@ -124,7 +124,7 @@ def inv(a, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> import mindspore.numpy as mnp
         >>> from mindspore.scipy.linalg import inv
         >>> a = Tensor(onp.array([[1., 2.], [3., 4.]]))
@@ -138,7 +138,7 @@ def inv(a, overwrite_a=False, check_finite=True):
     func_name = "inv"
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _square_check(func_name, a)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
 
@@ -150,11 +150,11 @@ def inv(a, overwrite_a=False, check_finite=True):
 
 def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
     """
-    Compute the cholesky decomposition of a matrix, to use in cho_solve.
+    Compute the cholesky decomposition of a matrix, to use in :func:`mindspore.scipy.linalg.cho_solve`.
 
     Returns a matrix containing the cholesky decomposition,
     :math:`a = l l*` or :math:`a = u* u` of a Hermitian positive-definite matrix `a`.
-    The return value can be directly used as the first parameter to `cho_solve`.
+    The return value can be directly used as the first parameter to :func:`mindspore.scipy.linalg.cho_solve`.
 
     Note:
         - `cho_factor` is not supported on Windows platform yet.
@@ -168,12 +168,13 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
 
     Args:
         a (Tensor): square Matrix of (M, M) to be decomposed.
-        lower (bool, optional): Whether to compute the upper or lower triangular cholesky factorization. Default: False.
-        overwrite_a(bool, optional): Whether to overwrite data in a (may improve performance). Default: False.
+        lower (bool, optional): Whether to compute the upper or lower triangular cholesky factorization.
+            Default: ``False`` .
+        overwrite_a(bool, optional): Whether to overwrite data in a (may improve performance). Default: ``False`` .
             in mindspore, this arg does not work right now.
         check_finite(bool, optional): Whether to check that the input matrix contains only finite numbers.
             Disabling may give a performance gain, but may result in problems
-            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True.
+            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: ``True`` .
             in mindspore, this arg does not work right now.
 
     Returns:
@@ -189,7 +190,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import cho_factor
         >>> a = Tensor(onp.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]]).astype(onp.float32))
         >>> c, low = cho_factor(a)
@@ -203,7 +204,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
     _type_check(func_name, lower, bool, 'lower')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
     _square_check(func_name, a)
 
@@ -231,12 +232,12 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
     Args:
         a (Tensor): square Matrix of (M, M) to be decomposed.
         lower (bool, optional): Whether to compute the upper- or lower-triangular cholesky
-            factorization. Default: False.
-        overwrite_a (bool, optional): Whether to overwrite data in `a` (may improve performance). Default: False.
+            factorization. Default: ``False`` .
+        overwrite_a (bool, optional): Whether to overwrite data in `a` (may improve performance). Default: ``False`` .
             in mindspore, this arg does not work right now.
         check_finite (bool, optional): Whether to check that the input matrix contains only finite numbers.
             Disabling may give a performance gain, but may result in problems
-            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True.
+            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: ``True`` .
             in mindspore, this arg does not work right now.
 
     Returns:
@@ -250,7 +251,7 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import cholesky
         >>> a = Tensor(onp.array([[1, 2],[2, 5]]).astype(onp.float32))
         >>> L = cholesky(a, lower=True)
@@ -262,7 +263,7 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
     _type_check(func_name, lower, bool, 'lower')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
     _square_check(func_name, a)
 
@@ -276,38 +277,40 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
 
 
 def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):
-    """Given the cholesky factorization of a, solve the linear equation
+    """
+    Given the cholesky factorization of a, solve the linear equation
 
     .. math::
         a x = b
 
     Note:
         - `cho_solve` is not supported on Windows platform yet.
-        - Only `float32`, `float64`, `int32`, `int64` are supported Tensor dtypes. If Tensor with dtype `int32` or
+        - Only `float32`, `float64`, `int32`, `int64` support Tensor dtypes. If Tensor with dtype `int32` or
           `int64` is passed, it will be cast to :class:`mstype.float64`.
 
     Args:
-        c_and_lower ((Tensor, bool)): cholesky factorization of a, as given by cho_factor.
+        c_and_lower ((Tensor, bool)): cholesky factorization of :math:`a`,
+            as given by :func:`mindspore.scipy.linalg.cho_factor`.
         b (Tensor): Right-hand side.
-        overwrite_b (bool, optional): Whether to overwrite data in b (may improve performance). Default: False.
+        overwrite_b (bool, optional): Whether to overwrite data in :math:`b` (may improve performance).
+            Default: ``False``.
         check_finite (bool, optional): Whether to check that the input matrices contain only finite numbers.
             Disabling may give a performance gain, but may result in problems
-            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True.
+            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: ``True``.
 
     Returns:
-        Tensor, the solution to the system a x = b
+        Tensor, the solution to the system a x = b.
 
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
-        >>> from mindspore.scipy.linalg import cho_factor, cho_solve
-        >>> a = Tensor(onp.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]]).astype(onp.float32))
-        >>> b = Tensor(onp.array([1, 1, 1, 1]).astype(onp.float32))
-        >>> c, low = cho_factor(a)
-        >>> x = cho_solve((c, low), b)
+        >>> import mindspore as ms
+        >>> a = ms.Tensor(onp.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]]).astype(onp.float32))
+        >>> b = ms.Tensor(onp.array([1, 1, 1, 1]).astype(onp.float32))
+        >>> c, low = ms.scipy.linalg.cho_factor(a)
+        >>> x = ms.scipy.linalg.cho_solve((c, low), b)
         >>> print(x)
         [-0.01749266  0.11953348  0.01166185  0.15743434]
     """
@@ -316,8 +319,8 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):
     _type_check(func_name, overwrite_b, bool, 'overwrite_b')
     _type_check(func_name, check_finite, bool, 'check_finite')
     _type_check(func_name, lower, bool, 'lower')
-    _mstype_check(func_name, c, mstype.tensor_type, 'c')
-    _mstype_check(func_name, b, mstype.tensor_type, 'b')
+    _mstype_check(func_name, c, mstype.TensorType, 'c')
+    _mstype_check(func_name, b, mstype.TensorType, 'b')
     _dtype_check(func_name, c, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'c')
     _dtype_check(func_name, b, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'b')
     _solve_check(func_name, c, b, 'c', 'b')
@@ -355,17 +358,17 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
     Note:
         - `eigh` is not supported on Windows platform yet.
         - Only `float32`, `float64`, `int32`, `int64` are supported Tensor dtypes. If Tensor with dtype `int32` or
-          `int64` is passed, it will be cast to :class:`mstype.float64`.
+          `int64` is passed, it will be cast to `mstype.float64`.
 
     Args:
         a (Tensor): A :math:`(M, M)` complex Hermitian or real symmetric matrix whose eigenvalues and
             eigenvectors will be computed.
         b (Tensor, optional): A :math:`(M, M)` complex Hermitian or real symmetric definite positive matrix in.
-            If omitted, identity matrix is assumed. Default: None.
+            If omitted, identity matrix is assumed. Default: ``None``.
         lower (bool, optional): Whether the pertinent Tensor data is taken from the lower or upper
-            triangle of `a` and, if applicable, `b`. Default: True.
+            triangle of `a` and, if applicable, `b`. Default: ``True``.
         eigvals_only (bool, optional): Whether to calculate only eigenvalues and no eigenvectors.
-            Default: False.
+            Default: ``False`` .
         type (int, optional): For the generalized problems, this keyword specifies the problem type
             to be solved for `w` and `v` (only takes 1, 2, 3 as possible inputs)::
 
@@ -373,24 +376,24 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
                 2 => a @ b @ v = w @ v
                 3 => b @ a @ v = w @ v
 
-            This keyword is ignored for standard problems. Default: 1.
-        overwrite_a (bool, optional): Whether to overwrite data in `a` (may improve performance). Default: False.
-        overwrite_b (bool, optional): Whether to overwrite data in `b` (may improve performance). Default: False.
+            This keyword is ignored for standard problems. Default: ``1`` .
+        overwrite_a (bool, optional): Whether to overwrite data in `a` (may improve performance). Default: ``False`` .
+        overwrite_b (bool, optional): Whether to overwrite data in `b` (may improve performance). Default: ``False`` .
         check_finite (bool, optional): Whether to check that the input matrices contain only finite numbers.
             Disabling may give a performance gain, but may result in problems (crashes, non-termination)
-            if the inputs do contain infinities or NaNs. Default: True.
+            if the inputs do contain infinities or NaNs. Default: ``True`` .
         turbo (bool, optional): use divide and conquer algorithm (faster but expensive in memory, only
             for generalized eigenvalue problem and if full set of eigenvalues are requested.).
-            Has no significant effect if eigenvectors are not requested. Default: True.
+            Has no significant effect if eigenvectors are not requested. Default: ``True`` .
         eigvals (tuple, optional): Indexes of the smallest and largest (in ascending order) eigenvalues
             and corresponding eigenvectors to be returned: :math:`0 <= lo <= hi <= M-1`. If omitted, all eigenvalues
-            and eigenvectors are returned. Default: None.
+            and eigenvectors are returned. Default: ``None`` .
 
     Returns:
         - Tensor with shape :math:`(N,)`, the :math:`N (1<=N<=M)` selected eigenvalues, in ascending order,
           each repeated according to its multiplicity.
 
-        - Tensor with shape :math:`(M, N)`, (if ``eigvals_only == False``)
+        - Tensor with shape :math:`(M, N)`, if `eigvals_only == False`.
 
     Raises:
         RuntimeError: If eigenvalue computation does not converge, an error occurred, or b matrix is not
@@ -413,7 +416,7 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
     Examples:
         >>> import numpy as onp
         >>> import mindspore.numpy as mnp
-        >>> from mindspore.common import Tensor, dtype
+        >>> from mindspore import Tensor, dtype
         >>> from mindspore.scipy.linalg import eigh
         >>> a = Tensor([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]], dtype.float64)
         >>> w, v = eigh(a)
@@ -431,7 +434,7 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
     eigh_type_check(turbo, bool, 'turbo')
     eigh_type_check(type, int, 'type')
     eigh_type_check(check_finite, bool, 'check_finite')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _dtype_check(func_name, a,
                  [mstype.int32, mstype.int64, mstype.float32, mstype.float64, mstype.complex64, mstype.complex128])
     _square_check(func_name, a)
@@ -458,8 +461,8 @@ def lu_pivots_to_permutation(pivots, permutation_size: int):
         loc = mnp.ix_(*(mnp.arange(0, b) for b in batch_dims))
         x = permutation[..., i]
         y = permutation[loc + (j,)]
-        permutation[..., i] = y
         permutation[loc + (j,)] = x
+        permutation[..., i] = y
     return permutation
 
 
@@ -483,10 +486,11 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
     Args:
         a (Tensor): square matrix of :math:`(M, M)` to decompose. Note that if the input tensor is not a `float`,
             then it will be cast to :class:'mstype.float32'.
-        overwrite_a (bool, optional): Whether to overwrite data in :math:`a` (may increase performance). Default: False.
+        overwrite_a (bool, optional): Whether to overwrite data in :math:`a` (may increase performance).
+            Default: ``False`` .
         check_finite (bool, optional): Whether to check that the input matrix contains only finite numbers.
             Disabling may give a performance gain, but may result in problems
-            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True.
+            (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: ``True`` .
 
     Returns:
         - Tensor, a square matrix of :math:`(N, N)` containing `U` in its upper triangle, and `L` in its lower triangle.
@@ -503,7 +507,7 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import lu_factor
         >>> a = Tensor(onp.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]).astype(onp.float64))
         >>> lu, piv = lu_factor(a)
@@ -518,7 +522,7 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
     func_name = "lu_factor"
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
     _square_check(func_name, a)
 
@@ -549,11 +553,13 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
     Args:
         a (Tensor): a :math:`(M, N)` matrix to decompose. Note that if the input tensor is not a `float`,
             then it will be cast to :class:'mstype.float32'.
-        permute_l (bool, optional): Perform the multiplication :math:`P L` (Default: do not permute). Default: False.
-        overwrite_a (bool, optional): Whether to overwrite data in :math:`a` (may improve performance). Default: False.
+        permute_l (bool, optional): Perform the multiplication :math:`P L` (Default: do not permute).
+            Default: ``False`` .
+        overwrite_a (bool, optional): Whether to overwrite data in :math:`a` (may improve performance).
+            Default: ``False`` .
         check_finite (bool, optional):  Whether to check that the input matrix contains
             only finite numbers. Disabling may give a performance gain, but may result
-            in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True.
+            in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: ``True`` .
 
     Returns:
         **If permute_l == False**
@@ -572,7 +578,7 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import lu
         >>> a = Tensor(onp.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]).astype(onp.float64))
         >>> p, l, u = lu(a)
@@ -596,7 +602,7 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
     _type_check(func_name, permute_l, bool, 'permute_l')
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
     _value_check(func_name, a.ndim, 2, 'a', 'dimension')
 
@@ -650,7 +656,7 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import lu_factor, lu_solve
         >>> a = Tensor(onp.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]).astype(onp.float64))
         >>> b = Tensor(onp.array([1, 1, 1, 1]).astype(onp.float64))
@@ -662,9 +668,9 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
     lu_matrix, pivot = lu_and_piv
     _type_check(func_name, overwrite_b, bool, 'overwrite_b')
     _type_check(func_name, check_finite, bool, 'check_finite')
-    _mstype_check(func_name, lu_matrix, mstype.tensor_type, 'lu_matrix')
-    _mstype_check(func_name, b, mstype.tensor_type, 'b')
-    _mstype_check(func_name, pivot, mstype.tensor_type, 'pivot')
+    _mstype_check(func_name, lu_matrix, mstype.TensorType, 'lu_matrix')
+    _mstype_check(func_name, b, mstype.TensorType, 'b')
+    _mstype_check(func_name, pivot, mstype.TensorType, 'pivot')
     _dtype_check(func_name, lu_matrix, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'lu_matrix')
     _dtype_check(func_name, b, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'b')
     _dtype_check(func_name, pivot, [mstype.int32], 'pivot')
@@ -741,7 +747,7 @@ def det(a, overwrite_a=False, check_finite=True):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.linalg import det
         >>> a = Tensor(onp.array([[0, 2, 3], [4, 5, 6], [7, 8, 9]])).astype(onp.float64)
         >>> print(det(a))
@@ -750,7 +756,7 @@ def det(a, overwrite_a=False, check_finite=True):
     func_name = "det"
     _type_check(func_name, overwrite_a, bool, 'overwrite_a')
     _type_check(func_name, check_finite, bool, 'check_finite')
-    _mstype_check(func_name, a, mstype.tensor_type)
+    _mstype_check(func_name, a, mstype.TensorType)
     _square_check(func_name, a)
     _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64])
 

mindspore/scipy/ops.py

@@ -61,7 +61,7 @@ class SolveTriangular(Primitive):
                  [1  1  1  1]       [2]
 
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> import mindspore.numpy as mnp
         >>> from mindspore.scipy.ops import SolveTriangular
         >>> a = Tensor(onp.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]], onp.float64))
@@ -88,42 +88,6 @@ class SolveTriangular(Primitive):
         self.init_prim_io_names(inputs=['a', 'b'], outputs=['output'])
 
 
-class Eigh(PrimitiveWithInfer):
-    """
-    Eigh decomposition(Symmetric matrix)
-    Ax = lambda * x
-    """
-
-    @prim_attr_register
-    def __init__(self, compute_eigenvectors=True, lower=True):
-        super().__init__(name="Eigh")
-        self.init_prim_io_names(inputs=['A'], outputs=['output_w', 'output_v'])
-        self.compute_eigenvectors = validator.check_value_type(
-            "compute_eigenvectors", compute_eigenvectors, [bool], self.name)
-        self.lower = validator.check_value_type("lower", lower, [bool], self.lower)
-        self.add_prim_attr('lower', self.lower)
-        self.add_prim_attr('compute_eigenvectors', self.compute_eigenvectors)
-
-    def __infer__(self, A):
-        validator.check_scalar_or_tensor_types_same({"A_dtype": A['dtype']},
-                                                    [mstype.float32, mstype.float64, mstype.complex64,
-                                                     mstype.complex128], self.name, True)
-        output = None
-        if self.compute_eigenvectors:
-            output = {
-                'shape': ((A['shape'][0],), (A['shape'][0], A['shape'][0])),
-                'dtype': (A['dtype'], A['dtype']),
-                'value': None
-            }
-        else:
-            output = {
-                'shape': (A['shape'][0],),
-                'dtype': A['dtype'],
-                'value': None
-            }
-        return output
-
-
 class Eig(PrimitiveWithInfer):
     """
     Eig decomposition,(generic matrix)
@@ -137,10 +101,10 @@ class Eig(PrimitiveWithInfer):
         self.compute_v = validator.check_value_type("compute_v", compute_v, [bool], self.name)
         self.add_prim_attr('compute_v', self.compute_v)
         self.io_table = {
-            mstype.tensor_type(mstype.float32): mstype.complex64,
-            mstype.tensor_type(mstype.complex64): mstype.complex64,
-            mstype.tensor_type(mstype.float64): mstype.complex128,
-            mstype.tensor_type(mstype.complex128): mstype.complex128
+            mstype.TensorType(mstype.float32): mstype.complex64,
+            mstype.TensorType(mstype.complex64): mstype.complex64,
+            mstype.TensorType(mstype.float64): mstype.complex128,
+            mstype.TensorType(mstype.complex128): mstype.complex128
         }
 
     def __infer__(self, a):

mindspore/scipy/ops_grad.py

@@ -14,12 +14,13 @@
 # ============================================================================
 """Grad implementation of operators for scipy submodule"""
 from .. import numpy as mnp
-from .ops import Eigh, Eig, SolveTriangular
+from .ops import Eig, SolveTriangular
 from .utils_const import _raise_type_error
 from .ops_wrapper import matrix_set_diag
 from ..ops import operations as P
 from ..ops import functional as F
-from ..ops._grad.grad_base import bprop_getters
+from ..ops.operations.linalg_ops import Eigh
+from ..ops._grad_experimental.grad_base import bprop_getters
 from ..common import dtype as mstype
 
 _matmul = P.MatMul(False, False)

mindspore/scipy/ops_wrapper.py

@@ -29,12 +29,12 @@ def matrix_set_diag(input_x, diagonal, k=0, alignment="RIGHT_LEFT"):
         diagonal (Tensor): a :math`(..., max_diag_len)`, or `(..., num_diags, max_diag_len)` vector to be placed to
             output's diags.
         k (Tensor): a scalar or 1D list. it's max length is to which indicates the diag's lower index and upper index.
-            (k[0], k[1]).
+            (k[0], k[1]). Default: ``0``.
         alignment (str): Some diagonals are shorter than `max_diag_len` and need to be padded.
             `align` is a string specifying how superdiagonals and subdiagonals should be aligned,
-             respectively. There are four possible alignments: "RIGHT_LEFT" (default),
-             "LEFT_RIGHT", "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to
-             the right (left-pads the row) and subdiagonals to the left (right-pads the row).
+             respectively. There are four possible alignments: "RIGHT_LEFT", "LEFT_RIGHT",
+             "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row)
+             and subdiagonals to the left (right-pads the row). Default: ``"RIGHT_LEFT"``.
 
     Returns:
         - Tensor, :math:`(...,M, N)`. a batched matrix with the same shape and values as `input`,
@@ -45,7 +45,7 @@ def matrix_set_diag(input_x, diagonal, k=0, alignment="RIGHT_LEFT"):
 
     Examples:
         >>> import numpy as onp
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.ops_wrapper import matrix_set_diag
         >>> input_x = Tensor(
         >>>     onp.array([[[7, 7, 7, 7],[7, 7, 7, 7], [7, 7, 7, 7]],

mindspore/scipy/optimize/line_search.py

@@ -316,12 +316,12 @@ def line_search(f, xk, pk, jac=None, gfk=None, old_fval=None, old_old_fval=None,
             The function can be None if you want to use automatic credits.
         xk (Tensor): initial guess.
         pk (Tensor): direction to search in. Assumes the direction is a descent direction.
-        gfk (Tensor): initial value of value_and_gradient as position. Default: None.
-        old_fval (Tensor): The same as `gfk`. Default: None.
-        old_old_fval (Tensor): unused argument, only for scipy API compliance. Default: None.
-        c1 (float): Wolfe criteria constant, see ref. Default: 1e-4.
-        c2 (float): The same as `c1`. Default: 0.9.
-        maxiter (int): maximum number of iterations to search. Default: 20.
+        gfk (Tensor): initial value of value_and_gradient as position. Default: ``None`` .
+        old_fval (Tensor): The same as `gfk`. Default: ``None`` .
+        old_old_fval (Tensor): unused argument, only for scipy API compliance. Default: ``None`` .
+        c1 (float): Wolfe criteria constant, see ref. Default: ``1e-4`` .
+        c2 (float): The same as `c1`. Default: ``0.9`` .
+        maxiter (int): maximum number of iterations to search. Default: ``20`` .
 
     Returns:
         LineSearchResults, results of line search results.
@@ -332,11 +332,11 @@ def line_search(f, xk, pk, jac=None, gfk=None, old_fval=None, old_old_fval=None,
     Examples:
         >>> import numpy as onp
         >>> from mindspore.scipy.optimize import line_search
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> x0 = Tensor(onp.ones(2).astype(onp.float32))
         >>> p0 = Tensor(onp.array([-1, -1]).astype(onp.float32))
         >>> def func(x):
-        >>>     return x[0] ** 2 - x[1] ** 3
+        ...     return x[0] ** 2 - x[1] ** 3
         >>> res = line_search(func, x0, p0)
         >>> print(res.a_k)
         1.0

mindspore/scipy/optimize/linear_sum_assignment.py

@@ -44,7 +44,7 @@ def _linear_sum_assignment(cost_matrix, maximize, dimension_limit=Tensor(sys.max
      Examples:
         >>> import mindspore as ms
         >>> import numpy as np
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> from mindspore.scipy.optimize.linear_sum_assignment import _linear_sum_assignment as lsap
         >>> cost_matrix = Tensor(np.array([[2, 3, 3], [3, 2, 3], [3, 3, 2]])).astype("float64")
         >>> dimension_limit = Tensor(2)
@@ -61,10 +61,10 @@ def _linear_sum_assignment(cost_matrix, maximize, dimension_limit=Tensor(sys.max
         [[0 1 2]]
     """
     func_name = 'linear_sum_assignment'
-    _mstype_check(func_name, cost_matrix, mstype.tensor_type, 'cost_matrix')
+    _mstype_check(func_name, cost_matrix, mstype.TensorType, 'cost_matrix')
     _mstype_check(func_name, dimension_limit,
-                  mstype.tensor_type, 'dimension_limit')
-    _mstype_check(func_name, maximize, mstype.tensor_type, 'maximize')
+                  mstype.TensorType, 'dimension_limit')
+    _mstype_check(func_name, maximize, mstype.TensorType, 'maximize')
     _dtype_check(func_name, cost_matrix, [mstype.float32, mstype.float64])
     _dtype_check(func_name, dimension_limit, [mstype.int64])
     _dtype_check(func_name, maximize, [mstype.bool_])

mindspore/scipy/optimize/minimize.py

@@ -92,26 +92,30 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
             `fun` must support differentiation if jac is None.
         x0 (Tensor): initial guess. Array of real elements of size :math:`(n,)`, where `n` is
             the number of independent variables.
-        args (Tuple): extra arguments passed to the objective function. Default: ().
+        args (Tuple): extra arguments passed to the objective function. Default: ``()`` .
         method (str): solver type. Should be one of `"BFGS"` and `"LBFGS"`, `"LAGRANGE"`.
         jac (Callable, optional): method for computing the gradient vector. Only for `"BFGS"` and `"LBFGS"`.
             if it is None, the gradient will be estimated with gradient of ``func``.
             if it is a callable, it should be a function that returns the gradient vector:
             :math:`jac(x, *args) -> array\_like, shape (n,)`
             where x is an array with shape :math:`(n,)` and args is a tuple with the fixed parameters.
-        tol (float, optional): tolerance for termination. For detailed control, use solver-specific
-            options. Default: None.
-        constraints(Callable, optional): representing the inequality constrains, each function in constrains indicates
+        hess (Callable, optional): Method for calculating the Hessian Matrix. Not implemented yet.
+        hessp (Callable, optional): Hessian of objective function times an arbitrary vector `p`. Not implemented yet.
+        bounds (Sequence, optional): Sequence of `(min, max)` pairs for each element in `x`. Not implemented yet.
+        constraints (Callable, optional): representing the inequality constrains, each function in constrains indicates
             the function < 0 as an inequality constrain.
+        tol (float, optional): tolerance for termination. For detailed control, use solver-specific
+            options. Default: ``None`` .
+        callback (Callable, optional): A callable called after each iteration. Not implemented yet.
         options (Mapping[str, Any], optional): a dictionary of solver options. All methods accept the following
-            generic options, Default: None.
+            generic options. Default: ``None`` .
 
             - history_size (int): size of buffer used to help to update inv hessian, only used with method="LBFGS".
-              Default: 20.
+              Default: ``20`` .
             - maxiter (int): Maximum number of iterations to perform. Depending on the
               method each iteration may use several function evaluations.
 
-        The follow options are exclusive to Lagrange method:
+            The follow options are exclusive to Lagrange method:
 
             - save_tol (list): list of saving tolerance, with the same length with 'constrains'.
             - obj_weight (float): weight for objective function, usually between 1.0 - 100000.0.
@@ -133,16 +137,16 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
     Examples:
         >>> import numpy as onp
         >>> from mindspore.scipy.optimize import minimize
-        >>> from mindspore.common import Tensor
+        >>> from mindspore import Tensor
         >>> x0 = Tensor(onp.zeros(2).astype(onp.float32))
         >>> def func(p):
-        >>>     x, y = p
-        >>>     return (x ** 2 + y - 11.) ** 2 + (x + y ** 2 - 7.) ** 2
+        ...     x, y = p
+        ...     return (x ** 2 + y - 11.) ** 2 + (x + y ** 2 - 7.) ** 2
         >>> res = minimize(func, x0, method='BFGS', options=dict(maxiter=None, gtol=1e-6))
         >>> print(res.x)
-        >>> l_res = minimize(func, x0, method='LBFGS', options=dict(maxiter=None, gtol=1e-6))
-        >>> print(res.x)
         [3. 2.]
+        >>> l_res = minimize(func, x0, method='LBFGS', options=dict(maxiter=None, gtol=1e-6))
+        >>> print(l_res.x)
         [3. 2.]
     """
     if method is None: