mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc1__cp38-cp38-manylinux1_x86_64.whl

mindspore/scipy/linalg.py

@@ -14,8 +14,7 @@
 # ============================================================================
 """Linear algebra submodule"""
 from __future__ import absolute_import
-from .ops import LU
-from .ops import SolveTriangular
+from .ops import LU, SolveTriangular
 from .utils import _nd_transpose, _value_check, _type_check, _dtype_check, _mstype_check, _square_check, _solve_check
 from .utils_const import _raise_value_error
 from .. import numpy as mnp
@@ -26,7 +25,74 @@ from ..ops.operations.linalg_ops import Eigh
 from ..ops import functional as F
 from ..ops import operations as P
 
-__all__ = ['block_diag', 'inv', 'cho_factor', 'cholesky', 'cho_solve', 'eigh', 'lu_factor', 'lu']
+__all__ = ['block_diag', 'inv', 'cho_factor', 'cholesky',
+           'cho_solve', 'eigh', 'lu_factor', 'lu', 'solve_triangular']
+
+
+def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True):
+    """
+    Solve the linear system :math:`a x = b` for `x`, Assuming `a` is a triangular matrix.
+
+    Note:
+        - `solve_triangular` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `solve_triangular` is not supported on Windows platform yet.
+
+    Args:
+        a (Tensor): A triangular matrix of shape :math:`(*, M, M)` where :math:`*` is zero or more batch dimensions.
+        b (Tensor): A Tensor of shape :math:`(*, M)` or :math:`(*, M, N)`. Right-hand side matrix in :math:`a x = b`.
+        trans (Union[int, str], optional): Type of system to solve. Default: ``0``.
+
+            ========  =========
+            trans     system
+            ========  =========
+            0 or 'N'  a x  = b
+            1 or 'T'  a^T x = b
+            2 or 'C'  a^H x = b
+            ========  =========
+
+        lower (bool, optional): Use only data contained in the lower triangle of `a`. Default: ``False``.
+        unit_diagonal (bool, optional): If ``True``, diagonal elements of :math:`a` are assumed to be 1 and
+            will not be referenced. Default: ``False``.
+        overwrite_b (bool, optional): Not implemented now. Default: ``False``.
+        debug (Any, optional): Not implemented now. Default: ``None``.
+        check_finite (bool, optional): Not implemented now. Default: ``True``.
+
+    Returns:
+        Tensor of shape :math:`(*, M)` or :math:`(*, M, N)`,
+        which is the solution to the system :math:`a x = b`.
+        Shape of :math:`x` matches :math:`b`.
+
+    Raises:
+        ValueError: If `a` is less than 2 dimension.
+        ValueError: if `a` is not square matrix.
+        TypeError: If dtype of `a` and `b` are not the same.
+        ValueError: If the shape of `a` and `b` are not matched.
+        ValueError: If `trans` is not in set {0, 1, 2, 'N', 'T', 'C'}.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import numpy as onp
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.scipy.linalg import solve_triangular
+        >>> a = Tensor(onp.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]], onp.float32))
+        >>> b = Tensor(onp.array([3, 1, 3, 4], onp.float32))
+        >>> x = solve_triangular(a, b, lower=True, unit_diagonal=False, trans='N')
+        >>> print(x)
+        [ 1. -1.  2.  2.]
+        >>> print(a @ x)  # Check the result
+        [3. 1. 3. 4.]
+    """
+    trans_str_to_int = {'N': 0, 'T': 1, 'C': 2}
+    if isinstance(trans, str):
+        trans = trans_str_to_int.get(trans)
+        if trans is None:
+            _raise_value_error(
+                "For SolveTriangular, Augment[trans] must be one of [1, 2, 3,'N', 'T', 'C'].")
+    return ops.auto_generate.solve_triangular(a, b, trans=trans, lower=lower, unit_diagonal=unit_diagonal)
 
 
 def block_diag(*arrs):
@@ -47,7 +113,7 @@ def block_diag(*arrs):
 
     Args:
         arrs (list): up to 2-D Input Tensors.
-            A 1-D Tensor or a 2-D Tensor with shape :math:`(1,n)`.
+            One or more Tensors, the dimension of Tensors should be 0-D, 1-D or 2-D.
 
     Returns:
         Tensor with `A`, `B`, `C`, ... on the diagonal which has the same dtype as `A`.
@@ -102,8 +168,8 @@ def inv(a, overwrite_a=False, check_finite=True):
 
     Note:
         - `inv` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     Args:
         a (Tensor): Square matrix to be inverted.
@@ -152,14 +218,21 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
     """
     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`.
+    Returns the cholesky decomposition of a Hermitian positive-definite matrix A. Base on the value of `lower`,
+    perform the following decomposition:
+
+    - when `lower` is True: :math:`A = L L^*`
+    - when `lower` is False: :math:`A = U^* U`
+
+    :math:`L^*` is a conjugate transpose matrix of :math:`L`.
+    :math:`U^*` is a conjugate transpose matrix of :math:`U`.
+
     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.
-        - 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     .. warning::
         The returned matrix also contains random data in the entries not
@@ -167,7 +240,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
         entries, use the function `cholesky` instead.
 
     Args:
-        a (Tensor): square Matrix of (M, M) to be decomposed.
+        a (Tensor): square Matrix of :math:`(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`` .
@@ -221,16 +294,22 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
     """
     Compute the cholesky decomposition of a matrix.
 
-    Returns the cholesky decomposition, :math:`a = l l^*` or
-    :math:`a = u^* u` of a Hermitian positive-definite matrix a.
+    Returns the cholesky decomposition of a Hermitian positive-definite matrix A. Base on the value of `lower`,
+    perform the following decomposition:
+
+    - when `lower` is True: :math:`A = L L^*`
+    - when `lower` is False: :math:`A = U^* U`
+
+    :math:`L^*` is a conjugate transpose matrix of L.
+    :math:`U^*` is a conjugate transpose matrix of U.
 
     Note:
         - `cholesky` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     Args:
-        a (Tensor): square Matrix of (M, M) to be decomposed.
+        a (Tensor): square Matrix of :math:`(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`` .
@@ -278,15 +357,15 @@ 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 :math:`A`, solve the linear equation.
 
     .. math::
-        a x = b
+        A x = b
 
     Note:
         - `cho_solve` is not supported on Windows platform yet.
-        - 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     Args:
         c_and_lower ((Tensor, bool)): cholesky factorization of :math:`a`,
@@ -299,7 +378,7 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=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 :math:`A x = b`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -347,7 +426,9 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
 
     Find eigenvalues Tensor `w` and optionally eigenvectors Tensor `v` of Tensor `a`,
     where `b` is positive definite such that for every eigenvalue `λ` (i-th entry of w) and
-    its eigenvector `vi` (i-th column of `v`) satisfies::
+    its eigenvector `vi` (i-th column of `v`) satisfies:
+
+    .. code-block::
 
                       a @ vi = λ * b @ vi
         vi.conj().T @ a @ vi = λ
@@ -357,8 +438,8 @@ 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 `mstype.float64`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or 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
@@ -369,25 +450,27 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
             triangle of `a` and, if applicable, `b`. Default: ``True``.
         eigvals_only (bool, optional): Whether to calculate only eigenvalues and no eigenvectors.
             Default: ``False`` .
+        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`` .
+        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`` .
+        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`` .
         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)::
+            to be solved for `w` and `v` (only takes 1, 2, 3 as possible inputs):
+
+            .. code-block::
 
                 1 =>     a @ v = w @ b @ v
                 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`` .
         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`` .
-        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`` .
-        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`` .
 
     Returns:
         - Tensor with shape :math:`(N,)`, the :math:`N (1<=N<=M)` selected eigenvalues, in ascending order,
@@ -406,7 +489,7 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
         TypeError: If `overwrite_b` is not bool.
         TypeError: If `turbo` is not bool.
         TypeError: If `check_finite` is not bool.
-        ValueError: If `a` is not square matrix.
+        ValueError: If `a` is not 2D square matrix.
         ValueError: If `b` is not None.
         ValueError: If `eigvals` is not None.
 
@@ -473,19 +556,19 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
     The decomposition is:
 
     .. math::
-        a = p l u
+        a = P L U
 
-    where :math:`p` is a permutation matrix, :math:`l` lower triangular with unit diagonal elements,
-    and :math:`u` upper triangular.
+    where :math:`P` is a permutation matrix, :math:`L` lower triangular with unit diagonal elements,
+    and :math:`U` upper triangular.
 
     Note:
         - `lu_factor` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     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'.
+        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 mstype.float32.
         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.
@@ -493,14 +576,14 @@ def lu_factor(a, overwrite_a=False, check_finite=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.
+        - Tensor, a square matrix of :math:`(M, M)` containing `U` in its upper triangle, and `L` in its lower triangle.
           The unit diagonal elements of `L` are not stored.
 
-        - Tensor, :math:`(N,)` pivot indices representing the permutation matrix `P`:
+        - Tensor, :math:`(M,)` pivot indices representing the permutation matrix `P`:
           the i-th element value j in the indices indicates that row i of matrix was interchanged with row j.
 
     Raises:
-        ValueError: If :math:`a` is not square.
+        ValueError: If :math:`a` is not 2D square.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -540,19 +623,19 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
     The decomposition is:
 
     .. math::
-        a = p l u
+        A = P L U
 
     where :math:`P` is a permutation matrix, :math:`L` lower triangular with unit
     diagonal elements, and :math:`U` upper triangular.
 
     Note:
         - `lu` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     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'.
+        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 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).
@@ -624,12 +707,12 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
 
 
 def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
-    """Solve an equation system, a x = b, given the LU factorization of a
+    """Solve an equation system, A x = B, given the LU factorization of A
 
     Note:
         - `lu_solve` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     Args:
         lu_and_piv (Tensor, Tensor): Factorization of the coefficient matrix a, as given by lu_factor
@@ -717,7 +800,9 @@ def det(a, overwrite_a=False, check_finite=True):
     The determinant of a square matrix is a value derived arithmetically
     from the coefficients of the matrix.
 
-    The determinant for a 3x3 matrix, for example, is computed as follows::
+    The determinant for a 3x3 matrix, for example, is computed as follows:
+
+    .. code-block::
 
         a    b    c
         d    e    f = A
@@ -727,8 +812,8 @@ def det(a, overwrite_a=False, check_finite=True):
 
     Note:
         - `det` 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`.
+        - Only float32, float64, int32, int64 are supported Tensor dtypes.
+        - If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.
 
     Args:
         a (Tensor): A square matrix to compute. Note that if the input tensor is not a `float`,

mindspore/scipy/ops.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2023 Huawei Technologies Co., Ltd
+# Copyright 2021-2024 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.
@@ -15,77 +15,19 @@
 """Operators for scipy submodule"""
 from mindspore import _checkparam as validator
 from ..ops import PrimitiveWithInfer, prim_attr_register, Primitive
+from ..ops.auto_generate import solve_triangular
 from ..common import dtype as mstype
 
 
-class SolveTriangular(Primitive):
-    """
-    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
-
-    Args:
-        a (Tensor): A triangular matrix of shape :math:`(..., N, N)`.
-        b (Tensor): A Tensor of shape :math:`(M,)` or :math:`(..., N, M)`.
-            Right-hand side matrix in :math:`a x = b`.
-        lower (bool, optional): Use only data contained in the lower triangle of `a`.
-            Default is to use upper triangle.
-        trans (0, 1, 2, 'N', 'T', 'C', optional):
-            Type of system to solve:
-            trans:        system:
-                0 or 'N'        a x  = b
-                1 or 'T'        a^T x = b
-                2 or 'C'        a^H x = b
-        unit_diagonal (bool, optional): If True, diagonal elements of :math:`a` are assumed to be 1 and
-            will not be referenced.
-        overwrite_b (bool, optional): Allow overwriting data in :math:`b` (may enhance performance)
-        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.
-
-    Returns:
-        Tensor of shape :math:`(..., M,)` or :math:`(..., M, N)`,
-        which is the solution to the system :math:`a x = b`.
-        Shape of :math:`x` matches :math:`b`.
-
-    Raises:
-        LinAlgError: If :math:`a` is singular
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        Solve the lower triangular system :math:`a x = b`, where:
-
-                 [3  0  0  0]       [4]
-            a =  [2  1  0  0]   b = [2]
-                 [1  0  1  0]       [4]
-                 [1  1  1  1]       [2]
-
-        >>> import numpy as onp
-        >>> 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))
-        >>> b = Tensor(onp.array([4, 2, 4, 2], onp.float64))
-        >>> solve_triangular = SolveTriangular(lower=True, unit_diagonal=False, trans='N')
-        >>> x = solve_triangular(a, b)
-        >>> print(x)
-        [ 1.33333333 -0.66666667  2.66666667 -1.33333333]
-        >>> print(mnp.dot(a, x))  # Check the result
-        [4. 2. 4. 2.]
-    """
-
-    @prim_attr_register
+class SolveTriangular():
     def __init__(self, lower: bool = False, unit_diagonal: bool = False, trans: str = 'N'):
-        """Initialize SolveTriangular"""
-        super(SolveTriangular, self).__init__("SolveTriangular")
-        self.lower = validator.check_value_type(
-            "lower", lower, [bool], self.name)
-        self.unit_diagonal = validator.check_value_type(
-            "unit_diagonal", unit_diagonal, [bool], self.name)
-        self.trans = validator.check_value_type(
-            "trans", trans, [str], self.name)
+        self.lower = lower
+        self.unit_diagonal = unit_diagonal
+        trans_str_to_int = {'N': 0, 'T': 1, 'C': 2}
+        self.trans = trans_str_to_int.get(trans)
 
-        self.init_prim_io_names(inputs=['a', 'b'], outputs=['output'])
+    def __call__(self, a, b):
+        return solve_triangular(a, b, self.trans, self.lower, self.unit_diagonal)
 
 
 class Eig(PrimitiveWithInfer):
@@ -97,9 +39,8 @@ class Eig(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self, compute_v=True):
         super().__init__(name="Eig")
-        self.init_prim_io_names(inputs=['a'], outputs=['w', 'v'])
         self.compute_v = validator.check_value_type("compute_v", compute_v, [bool], self.name)
-        self.add_prim_attr('compute_v', self.compute_v)
+        self._set_prim_arg("compute_v", compute_v)
         self.io_table = {
             mstype.TensorType(mstype.float32): mstype.complex64,
             mstype.TensorType(mstype.complex64): mstype.complex64,
@@ -129,6 +70,9 @@ class Eig(PrimitiveWithInfer):
             }
         return output
 
+    def __call__(self, a):
+        return super().__call__(a, self.compute_v)
+
 
 class LU(PrimitiveWithInfer):
     """
@@ -182,7 +126,7 @@ class LinearSumAssignment(Primitive):
         - **col_idx** (Tensor) - Column indices of the problem. If `dimension_limit` is given, -1 would be padded at
           the end. The shape is  :math:`(N, )` , where :math:`N` is the minimum value of `cost_matrix` dimension.
 
-     Raises:
+    Raises:
         TypeError: If the data type of `cost_matrix` is not the type in [float16, float32, float64,
                    int8, int16, int32, int64, uint8, uint16, uint32, uint64, bool]
         TypeError: If the type of `maximize` is not bool.
@@ -216,4 +160,4 @@ class LinearSumAssignment(Primitive):
         self.init_prim_io_names(inputs=['cost_matrix', 'dimension_limit', 'maximize'], outputs=['row_ind', 'col_ind'])
 
 # pylint: disable=C0413,W0611
-from .ops_grad import get_bprpo_eigh, get_bprpo_trsm
+from .ops_grad import get_bprpo_eigh

mindspore/scipy/ops_grad.py

@@ -14,15 +14,17 @@
 # ============================================================================
 """Grad implementation of operators for scipy submodule"""
 from .. import numpy as mnp
-from .ops import Eig, SolveTriangular
+from .ops import Eig
 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.operations.linalg_ops import Eigh
 from ..ops._grad_experimental.grad_base import bprop_getters
+from ..ops.composite import multitype_ops as C
 from ..common import dtype as mstype
 
+
 _matmul = P.MatMul(False, False)
 _real = P.Real()
 _conj = P.Conj()
@@ -59,9 +61,7 @@ def _batch_eyes(a):
 @bprop_getters.register(Eig)
 def get_bprpo_eig(self):
     """Grad definition for `Eig` operation."""
-    is_compute_v = self.compute_eigenvectors
-
-    def bprop(a, out, dout):
+    def bprop(a, is_compute_v, out, dout):
         w, v, grad_w, grad_v = out[0], out[1], dout[0], dout[1]
         if not is_compute_v:
             gw_vh = F.expand_dims(grad_w, -1) * _adjoint(v)
@@ -74,7 +74,7 @@ def get_bprpo_eig(self):
             f = _compute_f(w)
             grad_a = _diag(grad_w) + f * vh_gv
             grad_a = _matrix_solve(vh, _matmul(grad_a, vh))  # not support
-        return (grad_a,)
+        return (grad_a, C.zeros_like(is_compute_v))
 
     return bprop
 
@@ -113,32 +113,3 @@ def get_bprpo_eigh(self):
         return (grad_a,)
 
     return bprop
-
-
-@bprop_getters.register(SolveTriangular)
-def get_bprpo_trsm(self):
-    """Grad definition for `SolveTriangular` operation.
-    Appendix(see trsm) from Matthias Seeger, et al. 'Auto-Differentiating Linear Algebra', 2017, pg. 28-29
-    """
-    is_lower = self.lower
-    is_unit_diagonal = self.unit_diagonal
-    lower = int(is_lower)
-    bp_trans = ("N" if self.trans in ["T", "C"] else "T")
-    solve_triangular = SolveTriangular(is_lower, is_unit_diagonal, bp_trans)
-
-    def bprop(a, b, out, dout):
-        row_size = F.shape(a)[-2]
-        grad_b = solve_triangular(a, dout)
-        grad_b_align = F.reshape(grad_b, (row_size, -1))
-        x_align = F.reshape(out, (row_size, -1))
-        if bp_trans in ["T", "C"]:
-            grad_a = _matmul(grad_b_align, _adjoint(x_align))
-        else:
-            grad_a = _matmul(x_align, _adjoint(grad_b_align))
-
-        grad_a = -1 * F.matrix_band_part(grad_a, 0 - lower, lower - 1)
-        if is_unit_diagonal:
-            grad_a = matrix_set_diag(grad_a, F.fill(grad_a.dtype, (row_size,), 0))
-        return grad_a, grad_b
-
-    return bprop

mindspore/scipy/optimize/line_search.py

@@ -312,10 +312,10 @@ def line_search(f, xk, pk, jac=None, gfk=None, old_fval=None, old_old_fval=None,
     Args:
         f (function): function of the form f(x) where x is a flat Tensor and returns a real
             scalar. The function should be composed of operations with vjp defined.
-        gf (function): the gradient function at x where x is a flat Tensor and returns a Tensor.
-            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.
+        jac (function): the gradient function at x where x is a flat Tensor and returns a Tensor.
+            The function can be None if you want to use automatic credits.
         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`` .

mindspore/scipy/optimize/minimize.py

@@ -73,7 +73,7 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
     - Gradients of ``func`` are calculated automatically using MindSpore's autodiff
       support when the value of jac is None.
     - The ``method`` argument is required. A exception will be thrown if you don't specify a solver.
-    - Various optional arguments `"hess"` `"hessp"` `"bounds"` `"constraints"` `"tol"` `"callback"`
+    - Various optional arguments `"hess"`, `"hessp"`, `"bounds"`, `"constraints"`, `"tol"`, `"callback"`
       in the SciPy interface have not yet been implemented.
     - Optimization results may differ from SciPy due to differences in the line
       search implementation.

mindspore/train/__init__.py

@@ -26,7 +26,8 @@ from mindspore.train.amp import build_train_network
 from mindspore.train.loss_scale_manager import LossScaleManager, FixedLossScaleManager, DynamicLossScaleManager
 from mindspore.train.serialization import save_checkpoint, load_checkpoint, load_param_into_net, export, \
     load, parse_print, build_searched_strategy, merge_sliced_parameter, load_distributed_checkpoint, \
-    async_ckpt_thread_status, restore_group_info_list, convert_model, obfuscate_model, export_split_mindir
+    async_ckpt_thread_status, restore_group_info_list, convert_model, obfuscate_model, export_split_mindir, \
+    load_checkpoint_async
 from mindspore.train.callback import Callback, LossMonitor, TimeMonitor, ModelCheckpoint, SummaryCollector, \
     CheckpointConfig, RunContext, LearningRateScheduler, SummaryLandscape, \
     History, LambdaCallback, ReduceLROnPlateau, EarlyStopping, OnRequestExit, BackupAndRestore
@@ -39,7 +40,7 @@ __all__ = ["Model", "DatasetHelper", "connect_network_with_dataset", "build_trai
            "FixedLossScaleManager", "DynamicLossScaleManager", "save_checkpoint", "load_checkpoint",
            "load_param_into_net", "export", "load", "export_split_mindir", "parse_print", "build_searched_strategy",
            "merge_sliced_parameter", "load_distributed_checkpoint", "async_ckpt_thread_status",
-           "restore_group_info_list", "convert_model", "data_sink", "obfuscate_model"]
+           "restore_group_info_list", "convert_model", "data_sink", "obfuscate_model", "load_checkpoint_async"]
 __all__.extend(callback.__all__)
 __all__.extend(summary.__all__)
 __all__.extend(train_thor.__all__)