mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/scipy/optimize/minimize.py

@@ -18,6 +18,7 @@ from typing import NamedTuple
 from ...common import Tensor
 from ._bfgs import minimize_bfgs
 from ._lbfgs import minimize_lbfgs
+from ._lagrange import minimize_lagrange
 
 
 class OptimizeResults(NamedTuple):
@@ -47,10 +48,25 @@ class OptimizeResults(NamedTuple):
     nit: int
 
 
+def lagrange_para_check(func, constraints, options, tol):
+    """check the parameter of lagrange method."""
+
+    if not callable(func):
+        raise TypeError("'func' must be of type function, but got {}".format(type(func)))
+    if 'coincide_func' in options:
+        if not callable(options['coincide_fun']):
+            raise TypeError("'coincide_fun' must be of type function, but got {}".format(type(options['coincide_fun'])))
+    for constraint in constraints:
+        if not callable(constraint):
+            raise TypeError("'constraint' must be of type function, but got {}".format(type(constraint)))
+    if tol is not None:
+        if len(tol) != len(constraints):
+            raise ValueError("The len of tol must be same as the len of constraints")
+
+
 def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(),
              tol=None, callback=None, options=None):
-    r"""
-    Minimization of scalar function of one or more variables.
+    r"""Minimization of scalar function of one or more variables.
 
     This API for this function matches SciPy with some minor deviations:
 
@@ -67,6 +83,7 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
           multi-dimensional Tensor, but support for both is planned.
 
         - `minimize` is not supported on Windows platform yet.
+        -  `LAGRANGE` method is only supported on "GPU".
 
     Args:
         func (Callable): the objective function to be minimized, :math:`fun(x, *args) -> float`,
@@ -76,28 +93,42 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
         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: ().
-        method (str): solver type. Should be one of `"BFGS"` and `"LBFGS"`.
+        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 (n,) and args is a tuple with the fixed parameters.
+            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
+            the function < 0 as an inequality constrain.
         options (Mapping[str, Any], optional): a dictionary of solver options. All methods accept the following
             generic options, Default: None.
 
             - history_size (int): size of buffer used to help to update inv hessian, only used with method="LBFGS".
               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:
+
+            - 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.
+            - lower (Tensor): lower bound constrain for variables, must have same shape with x0.
+            - upper (Tensor): upper bound constrain for variables, must have same shape with x0.
+            - learning_rate (float): learning rate for each Adam step.
+            - coincide_func (Callable): sub-function representing the common parts between objective function
+              and constrains to avoid redundant computation.
+            - rounds (int): times to update Lagrange multipliers.
+            - steps (int): steps to apply Adam per round.
+            - log_sw (bool): whether to print the loss at each step.
+
     Returns:
         OptimizeResults, object holding optimization results.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -156,4 +187,10 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
                                njev=results.ngev,
                                nit=results.k)
 
+
+    if method.lower() == 'lagrange':
+        lagrange_para_check(func, constraints, options, tol)
+        results = minimize_lagrange(func, x0, constraints, tol, **options)
+        return results
+
     raise ValueError("Method {} not recognized".format(method))

mindspore/scipy/sparse/__init__.py

@@ -14,6 +14,6 @@
 # ============================================================================
 """Sparse submodule"""
 from . import linalg
-from .linalg import cg, gmres, bicgstab
+from .linalg import cg
 
-__all__ = ["cg", "gmres", "bicgstab"]
+__all__ = ["cg"]

mindspore/scipy/sparse/linalg.py

@@ -16,342 +16,11 @@
 from ... import nn
 from ... import numpy as mnp
 from ...ops import functional as F
-from ...ops import operations as P
-from ...common import Tensor, CSRTensor, COOTensor, dtype as mstype
+from ...common import Tensor, CSRTensor
 from ...ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from ..linalg import solve_triangular
-from ..linalg import cho_factor, cho_solve
-from ..utils import _to_tensor, _safe_normalize, _eps, _norm, _type_check, _value_check, \
+from ..utils import _to_tensor, _norm, _type_check, _value_check, \
     _sparse_check, _matvec
-from ..utils_const import _raise_value_error, _raise_type_error, is_within_graph
-
-
-def gram_schmidt(Q, q):
-    """Do Gram–Schmidt process to normalize vector v"""
-    h = mnp.dot(Q.T, q)
-    Qh = mnp.dot(Q, h)
-    q = q - Qh
-    return q, h
-
-
-def arnoldi_iteration(k, A, M, V, H):
-    """Performs a single (the k'th) step of the Arnoldi process."""
-    v_ = V[..., k]
-    v = _matvec(M, _matvec(A, v_))
-    v, h = gram_schmidt(V, v)
-    _, v_norm_0 = _safe_normalize(v)
-    tol = _eps(v) * v_norm_0
-    unit_v, v_norm_1 = _safe_normalize(v, tol)
-    V[..., k + 1] = unit_v
-    h[k + 1] = v_norm_1
-    H[k, :] = h
-    breakdown = v_norm_1 == 0
-    return V, H, breakdown
-
-
-def rotate_vectors(H, i, cs, sn):
-    """Rotate vectors."""
-    x1 = H[i]
-    y1 = H[i + 1]
-    x2 = cs * x1 - sn * y1
-    y2 = sn * x1 + cs * y1
-    H[i] = x2
-    H[i + 1] = y2
-    return H
-
-
-def _high_precision_cho_solve(a, b, data_type=mstype.float64):
-    """As a core computing module of gmres, cholesky solver must explicitly cast to double precision."""
-    a = a.astype(mstype.float64)
-    b = b.astype(mstype.float64)
-    a_a = mnp.dot(a, a.T)
-    a_b = mnp.dot(a, b)
-    c, lower = cho_factor(a_a, lower=False)
-    factor = (c, lower)
-    y = cho_solve(factor, a_b)
-    return y.astype(data_type)
-
-
-def _batch_gmres(A, b, x0, tol, restart, maxiter, M, atol):
-    """
-    batched gmres: solve the least squares problem from scratch at the end of each GMRES iteration.
-    It does not allow for early termination, but has much less overhead on GPUs.
-    """
-    # Constant tensor which avoids loop unrolling
-    const_int_zero = _to_tensor(0)
-    dtype = b.dtype
-    _, b_norm = _safe_normalize(b)
-    atol = mnp.maximum(tol * b_norm, _to_tensor(atol), dtype=dtype)
-    residual = _matvec(M, b - _matvec(A, x0))
-    unit_residual, residual_norm = _safe_normalize(residual)
-    k = const_int_zero
-    x = x0
-    while k < maxiter and residual_norm > atol:
-        pad_width = ((0, 0),) * unit_residual.ndim + ((0, restart),)
-        V = mnp.pad(unit_residual[..., None], pad_width=pad_width)
-        H = mnp.eye(restart, restart + 1, dtype=dtype)
-        k_iter = const_int_zero
-        breakdown = _to_tensor(False)
-        while k_iter < restart and mnp.logical_not(breakdown):
-            V, H, breakdown = arnoldi_iteration(k_iter, A, M, V, H)
-            k_iter += 1
-        beta_vec = mnp.zeros((restart + 1,), dtype=dtype)
-        beta_vec[0] = residual_norm
-        y = _high_precision_cho_solve(H, beta_vec, data_type=dtype)
-        dx = mnp.dot(V[..., :-1], y)
-        x = x + dx
-        residual = _matvec(M, b - _matvec(A, x))
-        unit_residual, residual_norm = _safe_normalize(residual)
-        k += 1
-    return x, F.select(residual_norm > atol, k, const_int_zero)
-
-
-def _incremental_gmres(A, b, x0, tol, restart, maxiter, M, atol):
-    """
-    incremental gmres: builds a QR decomposition for the Krylov subspace incrementally during
-    the GMRES process using Givens rotations. This improves numerical stability and gives a free estimate of
-    the residual norm that allows for early termination within a single "restart".
-    """
-    const_int_zero = _to_tensor(0)
-    _, b_norm = _safe_normalize(b)
-    atol = mnp.maximum(tol * b_norm, atol)
-
-    Mb = _matvec(M, b)
-    _, Mb_norm = _safe_normalize(Mb)
-    ptol = Mb_norm * mnp.minimum(1.0, atol / b_norm)
-
-    r = _matvec(M, b - _matvec(A, x0))
-    r, r_norm = _safe_normalize(r)
-
-    iters = const_int_zero
-    while iters < maxiter and r_norm > atol:
-        V = mnp.pad(r[..., None], ((0, 0),) * r.ndim + ((0, restart),))
-        dtype = mnp.result_type(b)
-        # Use eye() to avoid constructing a singular matrix in case of early
-        # Termination
-        R = mnp.eye(restart, restart + 1, dtype=dtype)
-        givens = mnp.zeros((restart, 2), dtype=dtype)
-        beta_vec = mnp.zeros((restart + 1), dtype=dtype)
-        beta_vec[0] = r_norm
-
-        k = const_int_zero
-        err = r_norm
-        while mnp.logical_and(mnp.less(k, restart), mnp.less(ptol, err)):
-            V, R, _ = arnoldi_iteration(k, A, M, V, R)
-            # Givens rotation
-            row_k = R[k, :]
-            i = const_int_zero
-            while i < k:
-                row_k = rotate_vectors(row_k, i, givens[i, 0], givens[i, 1])
-                i += 1
-
-            if row_k[k + 1] == 0:
-                givens[k, 0] = 1
-                givens[k, 1] = 0
-            else:
-                increase = mnp.absolute(row_k[k]) < mnp.absolute(row_k[k + 1])
-                t = mnp.where(increase, -row_k[k] / row_k[k + 1], -row_k[k + 1] / row_k[k])
-                r = 1 / F.sqrt(1 + mnp.absolute(t) ** 2)
-                givens[k, 0] = mnp.where(increase, r * t, r)
-                givens[k, 1] = mnp.where(increase, r, r * t)
-
-            R[k, :] = rotate_vectors(row_k, k, givens[k, 0], givens[k, 1])
-            beta_vec = rotate_vectors(beta_vec, k, givens[k, 0], givens[k, 1])
-            err = mnp.absolute(beta_vec[k + 1])
-            k += 1
-
-        y = solve_triangular(R[:, :-1], beta_vec[:-1], trans='T', lower=True)
-        dx = mnp.dot(V[:, :-1], y)
-
-        x = x0 + dx
-        r = _matvec(M, b - _matvec(A, x))
-        r, r_norm = _safe_normalize(r)
-        x0 = x
-        iters += 1
-    return x0, F.select(r_norm > atol, iters, const_int_zero)
-
-
-class GMRES(nn.Cell):
-    """
-    Given given A and b, GMRES solves the linear system:
-
-    .. math::
-        A x = b
-    """
-
-    def __init__(self, A, M, solve_method):
-        super(GMRES, self).__init__()
-        self.A = A
-        self.M = M
-        self.solve_method = solve_method
-
-    def construct(self, b, x0, tol, restart, maxiter, atol):
-        # Constant tensor which avoids loop unrolling
-        x = x0
-        info = _to_tensor(0)
-        if self.solve_method == 'batched':
-            x, info = _batch_gmres(self.A, b, x0, tol, restart, maxiter, self.M, atol)
-        elif self.solve_method == "incremental":
-            x, info = _incremental_gmres(self.A, b, x0, tol, restart, maxiter, self.M, atol)
-        else:
-            _raise_value_error("solve_method should be in ('incremental' or 'batched'), but got ", self.solve_method,
-                               ".")
-        return x, info
-
-
-class GMRESV2(nn.Cell):
-    """
-    This is a new version of GMRES, which contains all parameters in a graph.
-    """
-
-    def __init__(self, solve_method):
-        super(GMRESV2, self).__init__()
-        self.solve_method = solve_method
-
-    def transpose(self, a):
-        if isinstance(a, CSRTensor):
-            a_coo = a.to_coo()
-            row_indices = a_coo.indices[:, 0]
-            col_indices = a_coo.indices[:, 1]
-            coo_indices = P.Stack(1)([col_indices, row_indices])
-            a_t_coo = COOTensor(coo_indices, a_coo.values, a_coo.shape)
-            a_t_csr = a_t_coo.to_csr()
-            return a_t_csr
-        return a.T
-
-    def construct(self, A, b, x0, tol, restart, maxiter, M, atol):
-        x = x0
-        info = _to_tensor(0)
-        if self.solve_method == 'batched':
-            x, info = _batch_gmres(A, b, x0, tol, restart, maxiter, M, atol)
-        elif self.solve_method == "incremental":
-            x, info = _incremental_gmres(A, b, x0, tol, restart, maxiter, M, atol)
-        else:
-            _raise_value_error("solve_method should be in ('incremental' or 'batched'), but got ", self.solve_method,
-                               ".")
-        return x, info
-
-    def bprop(self, A, b, x0, tol, restart, maxiter, M, atol, out, dout):
-        """
-        Derivatives of `gmres` are implemented via implicit differentiation with
-        another `gmres` solve, rather than by differentiating *through* the solver.
-        They will be accurate only if both solves converge.
-        """
-        n = b.shape[0]
-        if not isinstance(M, (Tensor, CSRTensor)):
-            M = F.eye(n, n, b.dtype)
-        A_T = self.transpose(A)
-        grad_b, _ = self.construct(A_T, dout[0], x0, tol, restart, maxiter, M, atol)
-        if isinstance(A, CSRTensor):
-            grad_a_dense = -1 * F.reshape(grad_b, (n, 1)) * F.reshape(out[0], (1, n))
-            values = F.csr_gather(A.indptr, A.indices, grad_a_dense, A.shape)
-            grad_a = CSRTensor(A.indptr, A.indices, values, A.shape)
-        else:
-            grad_a = -1 * F.reshape(grad_b, (n, 1)) * F.reshape(out[0], (1, n))
-        return grad_a, grad_b, zeros_like(x0), zeros_like(tol), zeros_like(atol), zeros_like(maxiter), zeros_like(M)
-
-
-def gmres(A, b, x0=None, *, tol=1e-5, restart=20, maxiter=None,
-          M=None, callback=None, restrt=None, atol=0.0, callback_type=None, solve_method='batched'):
-    """
-    Given given A and b, GMRES solves the linear system:
-
-    .. math::
-        A x = b
-
-    A is specified as a function performing A(vi) -> vf = A @ vi, and in principle
-    need not have any particular special properties, such as symmetry. However,
-    convergence is often slow for nearly symmetric operators.
-
-    Note:
-        - `gmres` is not supported on Windows platform yet.
-
-    Args:
-        A (Union[Tensor, function]): 2D Tensor or function that calculates the linear
-            map (matrix-vector product) :math:`Ax` when called like :math:`A(x)`.
-            As function, `A` must return Tensor with the same structure and shape as its input matrix.
-        b (Tensor): Right hand side of the linear system representing a single vector.
-            Can be stored as a Tensor.
-        x0 (Tensor, optional): Starting guess for the solution. Must have the same structure
-            as `b`. If this is unspecified, zeroes are used. Default: None.
-        tol (float, optional): Tolerances for convergence,
-            :math:`norm(residual) <= max(tol*norm(b), atol)`. We do not implement SciPy's
-            "legacy" behavior, so MindSpore's tolerance will differ from SciPy unless you
-            explicitly pass `atol` to SciPy's `gmres`. Default: 1e-5.
-        restart (integer, optional): Size of the Krylov subspace ("number of iterations")
-            built between restarts. GMRES works by approximating the true solution x as its
-            projection into a Krylov space of this dimension - this parameter
-            therefore bounds the maximum accuracy achievable from any guess
-            solution. Larger values increase both number of iterations and iteration
-            cost, but may be necessary for convergence. The algorithm terminates
-            early if convergence is achieved before the full subspace is built. Default: 20.
-        maxiter (int): Maximum number of times to rebuild the size-`restart`
-            Krylov space starting from the solution found at the last iteration. If GMRES
-            halts or is very slow, decreasing this parameter may help. Default: None.
-        M (Union[Tensor, function]): Preconditioner for A.  The preconditioner should approximate the
-            inverse of A.  Effective preconditioning dramatically improves the
-            rate of convergence, which implies that fewer iterations are needed
-            to reach a given error tolerance. Default: None.
-        callback (function): User-supplied function to call after each iteration. It is called as callback(args),
-            where args are selected by callback_type. Default: None.
-        restrt (int, optional): Deprecated, use restart instead. Default: None.
-        atol (float, optional): The same as `tol`. Default: 0.0.
-        callback_type (str, optional): Callback function argument requested:
-            Default: None.
-
-            - x: current iterate (ndarray), called on every restart
-            - pr_norm: relative (preconditioned) residual norm (float), called on every inner iteration
-            - legacy (default): same as pr_norm, but also changes the meaning of ‘maxiter’ to count inner
-              iterations instead of restart cycles.
-
-        solve_method (str): There are two kinds of solve methods,'incremental' or 'batched'. Default: "batched".
-
-            - incremental: builds a QR decomposition for the Krylov subspace incrementally during
-              the GMRES process using Givens rotations. This improves numerical stability and gives
-              a free estimate of the residual norm that allows for early termination within a single "restart".
-            - batched: solve the least squares problem from scratch at the end of each GMRES
-              iteration. It does not allow for early termination, but has much less overhead on GPUs.
-
-    Returns:
-        - Tensor, the converged solution. Has the same structure as `b`.
-        - Tensor, placeholder for convergence information: 0 : successful exit.
-          >0 : convergence to tolerance not achieved, number of iterations. <0 : illegal input or breakdown.
-
-    Supported Platforms:
-        ``CPU`` ``GPU``
-
-    Examples:
-        >>> import numpy as onp
-        >>> import mindspore.numpy as mnp
-        >>> from mindspore.common import Tensor
-        >>> from mindspore.scipy.sparse.linalg import gmres
-        >>> A = Tensor(mnp.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=mnp.float32))
-        >>> b = Tensor(mnp.array([2, 4, -1], dtype=mnp.float32))
-        >>> x, exitCode = gmres(A, b)
-        >>> print(exitCode)            # 0 indicates successful convergence
-        0
-        >>> print(onp.allclose(mnp.dot(A,x).asnumpy(), b.asnumpy()))
-        True
-    """
-    func_name = "gmres"
-    A, M, b, x0 = _sparse_check(func_name, A, M, b, x0)
-    size = b.size
-    if maxiter is None:
-        maxiter = 10 * size  # copied from scipy
-    _type_check(func_name, tol, float, 'tol')
-    _type_check(func_name, restart, int, 'restart')
-    _type_check(func_name, maxiter, int, 'maxiter')
-    _type_check(func_name, solve_method, str, 'solve_method')
-    _value_check(func_name, callback, None, 'callback', op='is', fmt='todo')
-    _value_check(func_name, restrt, None, 'restrt', op='is', fmt='todo')
-    _value_check(func_name, callback_type, None, 'callback_type', op='is', fmt='todo')
-    if restart > size:
-        restart = size
-    if not is_within_graph(A):
-        x, info = GMRES(A, M, solve_method)(b, x0, tol, restart, maxiter, atol)
-    else:
-        x, info = GMRESV2(solve_method)(A, b, x0, tol, restart, maxiter, M, atol)
-    return x, info
+from ..utils_const import is_within_graph
 
 
 def _cg(A, b, x0, tol, atol, maxiter, M):
@@ -493,7 +162,7 @@ def cg(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None, callback=None
         TypeError: If `A` and `b` don't have the same data types.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -516,137 +185,8 @@ def cg(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None, callback=None
     _type_check(func_name, maxiter, int, 'maxiter')
     _value_check(func_name, callback, None, 'callback', op='is', fmt='todo')
 
-    if not is_within_graph(A):
+    if not is_within_graph(b):
         x, info = CG(A, M)(b, x0, tol, atol, maxiter)
     else:
         x, info = CGv2()(A, b, x0, tol, atol, maxiter, M)
     return x, info
-
-
-class BiCGStab(nn.Cell):
-    """Figure 2.10 from Barrett R, et al. 'Templates for the sulution of linear systems:
-    building blocks for iterative methods', 1994, pg. 24-25
-    """
-
-    def __init__(self, A, M):
-        super(BiCGStab, self).__init__()
-        self.A = A
-        self.M = M
-
-    def construct(self, b, x0, tol, atol, maxiter):
-        # Constant tensors which avoid loop unrolling
-        const_int_zero = _to_tensor(0)
-        const_int_neg_one = _to_tensor(-1)
-
-        const_float_one = _to_tensor(1., dtype=b.dtype)
-        atol_ = mnp.maximum(atol, tol * _norm(b))
-
-        r = r_tilde = v = p = b - _matvec(self.A, x0)
-        rho = alpha = omega = const_float_one
-        k = const_int_zero
-        x = x0
-        while k < maxiter:
-            rho_ = mnp.dot(r_tilde, r)
-            if rho_ == 0. or omega == 0.:
-                k = const_int_neg_one
-                break
-
-            beta = rho_ / rho * (alpha / omega)
-            p = r + beta * (p - omega * v)
-            p_hat = _matvec(self.M, p)
-            v = _matvec(self.A, p_hat)
-            alpha = rho_ / mnp.dot(r_tilde, v)
-            s = r - alpha * v
-            x = x + alpha * p_hat
-            if _norm(s) <= atol_:
-                break
-
-            s_hat = _matvec(self.M, s)
-            t = _matvec(self.A, s_hat)
-            omega = mnp.dot(t, s) / mnp.dot(t, t)
-            x = x + omega * s_hat
-            r = s - omega * t
-            if _norm(r) <= atol_:
-                break
-
-            rho = rho_
-            k += 1
-
-        return x, F.select(k == const_int_neg_one or k >= maxiter, k, const_int_zero)
-
-
-def bicgstab(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None):
-    """Use Bi-Conjugate Gradient Stable iteration to solve :math:`Ax = b`.
-
-    The numerics of MindSpore's `bicgstab` should exact match SciPy's
-    `bicgstab` (up to numerical precision).
-
-    As with `cg`, derivatives of `bicgstab` are implemented via implicit
-    differentiation with another `bicgstab` solve, rather than by
-    differentiating *through* the solver. They will be accurate only if
-    both solves converge.
-
-    Note:
-        - `bicgstab` is not supported on Windows platform yet.
-
-    Args:
-        A (Union[Tensor, function]): 2D Tensor or function that calculates the linear
-            map (matrix-vector product) :math:`Ax` when called like :math:`A(x)`.
-            As function, `A` must return Tensor with the same structure and shape as its input matrix.
-        b (Tensor): Right hand side of the linear system representing a single vector. Can be
-            stored as a Tensor.
-        x0 (Tensor): Starting guess for the solution. Must have the same structure as `b`. Default: None.
-        tol (float, optional): Tolerances for convergence, :math:`norm(residual) <= max(tol*norm(b), atol)`.
-            We do not implement SciPy's "legacy" behavior, so MindSpore's tolerance will
-            differ from SciPy unless you explicitly pass `atol` to SciPy's `bicgstab`. Default: 1e-5.
-        atol (float, optional): The same as `tol`. Default: 0.0.
-        maxiter (int): Maximum number of iterations.  Iteration will stop after maxiter
-            steps even if the specified tolerance has not been achieved. Default: None.
-        M (Union[Tensor, function]): Preconditioner for A.  The preconditioner should approximate the
-            inverse of A. Effective preconditioning dramatically improves the
-            rate of convergence, which implies that fewer iterations are needed
-            to reach a given error tolerance. Default: None.
-
-    Returns:
-        - Tensor, the converged solution. Has the same structure as `b`.
-        - Tensor, placeholder for convergence information: 0 : successful exit.
-          >0 : convergence to tolerance not achieved, number of iterations. <0 : illegal input or breakdown.
-
-    Raises:
-        ValueError: If `x0` and `b` don't have the same structure.
-        TypeError: If `A`, `x0` and `b` don't have the same float types(`mstype.float32` or `mstype.float64`).
-
-    Supported Platforms:
-        ``CPU`` ``GPU``
-
-    Examples:
-        >>> import numpy as onp
-        >>> from mindspore.common import Tensor
-        >>> from mindspore.scipy.sparse.linalg import bicgstab
-        >>> A = Tensor(onp.array([[1, 2], [2, 1]], dtype='float32'))
-        >>> b = Tensor(onp.array([1, -1], dtype='float32'))
-        >>> result, info = bicgstab(A, b)
-        >>> print(result)
-        [-1.  1.]
-        >>> print(info)
-        0
-    """
-    if x0 is None:
-        x0 = mnp.zeros_like(b)
-
-    if maxiter is None:
-        maxiter = 10 * b.shape[0]
-
-    if M is None:
-        M = lambda x: x
-
-    if x0.shape != b.shape:
-        _raise_value_error(
-            'Input x0 and b must have matching shapes: ', x0.shape, ' vs ', b.shape)
-
-    if (F.dtype(b) not in (mstype.float32, mstype.float64)) or (F.dtype(b) != F.dtype(x0)) or (
-            F.dtype(b) != F.dtype(A)):
-        _raise_type_error('Input A, x0 and b must have same float types')
-
-    x, info = BiCGStab(A, M)(b, x0, tol, atol, maxiter)
-    return x, info

mindspore/scipy/utils.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """internal utility functions"""
+from __future__ import division
 from .. import ops
 from .. import numpy as mnp
 from ..numpy import where, zeros_like, dot, greater
@@ -156,7 +157,7 @@ def _solve_check(func_name, arg1, arg2, arg1_name='a', arg2_name='b', sparse=Fal
 
 
 def _sparse_check(func_name, a, m, b, x0):
-    """Used for cg, bicgstab and gmres method."""
+    """Used for cg method."""
 
     def _check_right(arg, arg_name):
         if arg is None:

mindspore/scipy/utils_const.py

@@ -16,6 +16,7 @@
 from __future__ import absolute_import
 from types import FunctionType
 from collections.abc import Iterable
+from mindspore.ops import functional as F
 from .. import context
 from ..ops.primitive import constexpr
 from ..common import Tensor, CSRTensor
@@ -29,13 +30,18 @@ def _callable_const(x):
 
 
 @constexpr
+def is_pynative():
+    """Returns true if the current mode is PYNATIVE mode."""
+    return context.get_context("mode") == context.PYNATIVE_MODE
+
+
 def is_within_graph(x):
     """
     Returns true if x is None. It's aim to check whether the call is within MindSpore graph.
     Because in graph mode, x should be None in constexpr when x is a variable of MindSpore.
     Note that always return true if the call is in pynative mode.
     """
-    return context.get_context("mode") == context.PYNATIVE_MODE or x is None
+    return is_pynative() or not F.isconstant(x) or x is None
 
 
 @constexpr

mindspore/train/__init__.py

@@ -26,19 +26,21 @@ 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
+    async_ckpt_thread_status, restore_group_info_list, convert_model, obfuscate_model
 from mindspore.train.callback import Callback, LossMonitor, TimeMonitor, ModelCheckpoint, SummaryCollector, \
     CheckpointConfig, RunContext, LearningRateScheduler, SummaryLandscape, \
-    History, LambdaCallback, ReduceLROnPlateau, EarlyStopping
+    History, LambdaCallback, ReduceLROnPlateau, EarlyStopping, OnRequestExit, BackupAndRestore
 from mindspore.train.summary import SummaryRecord
 from mindspore.train.train_thor import ConvertNetUtils, ConvertModelUtils
+from mindspore.train.metrics import *
 from mindspore.train.data_sink import data_sink
 
-__all__ = ["Model", "DatasetHelper", "amp", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
+__all__ = ["Model", "DatasetHelper", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
            "FixedLossScaleManager", "DynamicLossScaleManager", "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",
-           "data_sink"]
+           "data_sink", "obfuscate_model"]
 __all__.extend(callback.__all__)
 __all__.extend(summary.__all__)
 __all__.extend(train_thor.__all__)
+__all__.extend(metrics.__all__)