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

mindspore/scipy/linalg.py

@@ -14,7 +14,6 @@
 # ============================================================================
 """Linear algebra submodule"""
 from __future__ import absolute_import
-from .ops import Cholesky
 from .ops import Eigh
 from .ops import LU
 from .ops import SolveTriangular
@@ -23,10 +22,11 @@ from .utils_const import _raise_value_error
 from .. import numpy as mnp
 from .. import ops
 from ..common import dtype as mstype
+from ..ops.operations.math_ops import Cholesky
 from ..ops import functional as F
 from ..ops import operations as P
 
-__all__ = ['block_diag', 'solve_triangular', 'inv', 'cho_factor', 'cholesky', 'cho_solve', 'eigh', 'lu_factor', 'lu']
+__all__ = ['block_diag', 'inv', 'cho_factor', 'cholesky', 'cho_solve', 'eigh', 'lu_factor', 'lu']
 
 
 def block_diag(*arrs):
@@ -56,7 +56,7 @@ def block_diag(*arrs):
         ValueError: If there are Tensors with dimensions higher than 2 in all arguments.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -96,110 +96,6 @@ def block_diag(*arrs):
     return accum
 
 
-def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,
-                     overwrite_b=False, debug=None, check_finite=True):
-    """
-    Assuming a is a batched triangular matrix, solve the equation
-
-    .. math::
-        a x = b
-
-    Note:
-        - `solve_triangular` 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`.
-        - The floating point error will accumulate when the size of input matrix gets larger. Substituting
-          result `x` back into :math:`a x = b` would be a way to evaluate the result. If the input shape is large
-          enough, using `float64` instead of `float32` is also a way to mitigate the error.
-
-    Args:
-        a (Tensor): A non-singular triangular matrix of shape :math:`(M, M)`.
-        b (Tensor): A Tensor of shape :math:`(M,)` or :math:`(M, N)`. Right-hand side matrix in :math:`a x = b`.
-        lower (bool, optional): Use only data contained in the lower triangle of `a`. Default: False.
-        trans (0, 1, 2, 'N', 'T', 'C', 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
-            ========  =========
-        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): Allow overwriting data in :math:`b` (may enhance performance). Default: False.
-        debug (None): Not implemented now. Default: None.
-        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.
-
-    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:
-        TypeError: If `a` is not Tensor.
-        ValueError: If `a` is not 2 dimension.
-        TypeError: If `b` is not Tensor.
-        ValueError: If `b` is not 1 or 2 dimension.
-        TypeError: If dtype of `a` and `b` are not the same.
-        ValueError: If the shape of `a` and `b` are not matched.
-        TypeError: If `trans` is not int or str.
-        ValueError: If `trans` is not in set {0, 1, 2, 'N', 'T', 'C'}.
-        TypeError: If `lower` is not bool.
-        TypeError: If `unit_diagonal` is not bool.
-        TypeError: If `overwrite_b` is not bool.
-        TypeError: If `check_finite` is not bool.
-        ValueError: If `debug` is not None.
-        ValueError: If `a` is singular matrix.
-
-    Supported Platforms:
-        ``CPU`` ``GPU``
-
-    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.common import Tensor
-        >>> import mindspore.numpy as mnp
-        >>> 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.float64))
-        >>> b = Tensor(onp.array([4, 2, 4, 2], onp.float64))
-        >>> x = solve_triangular(a, b, lower=True, unit_diagonal=False, trans='N')
-        >>> print(x)
-        [ 1.33333333 -0.66666667  2.66666667 -1.33333333]
-        >>> print(mnp.dot(a, x))  # Check the result
-        [4. 2. 4. 2.]
-    """
-    func_name = 'solve_triangular'
-    _mstype_check(func_name, a, mstype.tensor_type, 'a')
-    _mstype_check(func_name, b, mstype.tensor_type, 'b')
-    _type_check(func_name, trans, (int, str), 'trans')
-    _type_check(func_name, lower, bool, 'lower')
-    _type_check(func_name, overwrite_b, bool, 'overwrite_b')
-    _type_check(func_name, check_finite, bool, 'check_finite')
-    _dtype_check(func_name, a, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'a')
-    _dtype_check(func_name, b, [mstype.int32, mstype.int64, mstype.float32, mstype.float64], 'b')
-    _solve_check(func_name, a, b)
-    _value_check(func_name, debug, None, 'debug', op='is', fmt='todo')
-    _value_check(func_name, trans, (0, 1, 2, 'N', 'T', 'C'), "trans", "value")
-
-    if F.dtype(a) in (mstype.int32, mstype.int64):
-        a = F.cast(a, mstype.float64)
-        b = F.cast(b, mstype.float64)
-    if isinstance(trans, int):
-        trans_table = ['N', 'T', 'C']
-        trans = trans_table[trans]
-    solve = SolveTriangular(lower, unit_diagonal, trans)
-    return solve(a, b)
-
-
 def inv(a, overwrite_a=False, check_finite=True):
     """
     Compute the inverse of a matrix.
@@ -224,7 +120,7 @@ def inv(a, overwrite_a=False, check_finite=True):
         ValueError: If :math:`a` is not square, or not 2D.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -289,7 +185,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
         ValueError: If input a tensor is not a square matrix or it's dims not equal to 2D.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -313,7 +209,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
 
     if F.dtype(a) in (mstype.int32, mstype.int64):
         a = F.cast(a, mstype.float64)
-    cholesky_net = Cholesky(clean=False)
+    cholesky_net = Cholesky()
     c = cholesky_net(a)
     if not lower:
         c = _nd_transpose(c)
@@ -350,7 +246,7 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
         ValueError: If input a tensor is not a square matrix or it's dims not equal to 2D.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -372,7 +268,7 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
 
     if F.dtype(a) in (mstype.int32, mstype.int64):
         a = F.cast(a, mstype.float64)
-    cholesky_net = Cholesky(clean=True)
+    cholesky_net = Cholesky()
     c = cholesky_net(a)
     if not lower:
         c = _nd_transpose(c)
@@ -402,7 +298,7 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):
         Tensor, the solution to the system a x = b
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -512,7 +408,7 @@ def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,
         ValueError: If `eigvals` is not None.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -603,7 +499,7 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
         ValueError: If :math:`a` is not square.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -672,7 +568,7 @@ def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
         - Tensor, :math:`(K, N)` upper triangular or trapezoidal matrix.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -750,7 +646,7 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
         Tensor, solution to the system
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp

mindspore/scipy/ops.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """Operators for scipy submodule"""
+from mindspore import _checkparam as validator
 from ..ops import PrimitiveWithInfer, prim_attr_register, Primitive
-from .._checkparam import Validator as validator
 from ..common import dtype as mstype
 
 
-class SolveTriangular(PrimitiveWithInfer):
+class SolveTriangular(Primitive):
     """
     Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
 
@@ -50,7 +50,7 @@ class SolveTriangular(PrimitiveWithInfer):
         LinAlgError: If :math:`a` is singular
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         Solve the lower triangular system :math:`a x = b`, where:
@@ -87,73 +87,6 @@ class SolveTriangular(PrimitiveWithInfer):
 
         self.init_prim_io_names(inputs=['a', 'b'], outputs=['output'])
 
-    def __infer__(self, a, b):
-        a_shape = a['shape']
-        b_shape = b['shape']
-        # shape match
-        b_vector = len(b_shape) == len(a_shape) - 1
-        if len(a_shape) < 2:
-            raise ValueError(f"For '{self.name}', the dimension of `a` should be at least 2,"
-                             f" but got {len(a_shape)} dimensions.")
-        b_len = 1 if b_vector else 2
-        if len(b_shape) < b_len:
-            raise ValueError(f"For '{self.name}', the dimension of `b` should be at least {b_len},"
-                             f" but got {len(b_shape)} dimensions.")
-        if len(a_shape) != len(b_shape) and len(a_shape) - 1 != len(b_shape):
-            raise ValueError(f"For '{self.name}', the dimension of `b` should be 'a.dim' or 'a.dim' - 1, "
-                             f"which is {len(a_shape)} or {len(a_shape) - 1}, but got {len(b_shape)} dimensions.")
-        if a_shape[-1] != a_shape[-2]:
-            raise ValueError(f"For '{self.name}', the last two dimensions of `a` should be the same,"
-                             f" but got shape of {a_shape}."
-                             f" Please make sure that the shape of `a` be like [..., N, N]")
-        if a_shape[-2] != b_shape[-b_len]:
-            raise ValueError(f"For '{self.name}', the last two dimensions of `a` and `b` should be matched,"
-                             f" but got shape of {a_shape} and {b_shape}."
-                             f" Please make sure that the shape of `a` and `b` be like"
-                             f" [..., N, N] X [..., N, M] or [..., N, N] X [..., N].")
-        if a_shape[:-2] != b_shape[:-b_len]:
-            raise ValueError(f"For '{self.name}', the batch dimensions of `a` and `b` should all be the same,"
-                             f" but got shape of {a_shape} and {b_shape}."
-                             f" Please make sure that the shape of `a` and `b` be like"
-                             f" [a, b, c, ..., N, N] X [a, b, c, ..., N, M] or"
-                             f" [a, b, c, ..., N, N] X [a, b, c, ..., N].")
-
-        validator.check_scalar_or_tensor_types_same({"a_dtype": a['dtype'], "b_dtype": b['dtype']},
-                                                    [mstype.float32, mstype.float64], self.name)
-        return {
-            'shape': tuple(b_shape),
-            'dtype': a['dtype'],
-            'value': None
-        }
-
-    def infer_dtype(self, a_dtype, b_dtype):
-        del b_dtype
-        return a_dtype
-
-
-class Cholesky(PrimitiveWithInfer):
-    """
-    Inner API Cholesky Compute the Cholesky decomposition of a matrix.
-    clean is a special args for mindspore.scipy to indicate whether clean useless triangular matrix data.
-    """
-
-    @prim_attr_register
-    def __init__(self, clean=True):
-        super().__init__("Cholesky")
-        self.init_prim_io_names(inputs=['a'], outputs=['l'])
-        self.clean = validator.check_value_type("clean", clean, [bool], self.name)
-        self.add_prim_attr('clean', self.clean)
-
-    def __infer__(self, a):
-        a_shape = a['shape']
-        out_shape = a_shape
-        output = {
-            'shape': tuple(out_shape),
-            'dtype': a['dtype'],
-            'value': None
-        }
-        return output
-
 
 class Eigh(PrimitiveWithInfer):
     """
@@ -260,6 +193,7 @@ class LU(PrimitiveWithInfer):
 
 class LinearSumAssignment(Primitive):
     """Solve the linear sum assignment problem."""
+
     @prim_attr_register
     def __init__(self):
         super().__init__("LinearSumAssignment")
@@ -268,4 +202,4 @@ class LinearSumAssignment(Primitive):
 
 
 # pylint: disable=C0413,W0611
-from .ops_grad import get_bprop_cholesky, get_bprpo_eigh, get_bprpo_trsm
+from .ops_grad import get_bprpo_eigh, get_bprpo_trsm

mindspore/scipy/ops_grad.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """Grad implementation of operators for scipy submodule"""
 from .. import numpy as mnp
-from .ops import Eigh, Eig, Cholesky, SolveTriangular
+from .ops import Eigh, Eig, SolveTriangular
 from .utils_const import _raise_type_error
 from .ops_wrapper import matrix_set_diag
 from ..ops import operations as P
@@ -55,30 +55,6 @@ def _batch_eyes(a):
     return mnp.broadcast_to(eye, shape)
 
 
-@bprop_getters.register(Cholesky)
-def get_bprop_cholesky(self):
-    """Grad definition for `Cholesky` operation."""
-    matmul = P.MatMul()
-    solve_triangular = SolveTriangular(lower=True, unit_diagonal=False, trans='N')
-    clean = self.clean
-
-    def bprop(a, out, dout):
-        l = out
-        if not clean:
-            l = F.matrix_band_part(out, -1, 0)
-        eyes = _batch_eyes(l)
-        l_inverse = solve_triangular(l, eyes)
-        dout_middle = matmul(_adjoint(l), dout)
-        middle_diag = 0.5 * dout_middle.diagonal(0, -2, -1)
-        dout_middle = matrix_set_diag(dout_middle, middle_diag)
-        dout_middle = F.matrix_band_part(dout_middle, -1, 0)
-        grad_a = matmul(matmul(_adjoint(l_inverse), dout_middle), l_inverse)
-        grad_a = 0.5 * (grad_a + _adjoint(grad_a))
-        return (grad_a,)
-
-    return bprop
-
-
 @bprop_getters.register(Eig)
 def get_bprpo_eig(self):
     """Grad definition for `Eig` operation."""

mindspore/scipy/ops_wrapper.py

@@ -41,7 +41,7 @@ def matrix_set_diag(input_x, diagonal, k=0, alignment="RIGHT_LEFT"):
             except for the specified diagonals of the innermost matrices.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp

mindspore/scipy/optimize/_bfgs.py

@@ -188,7 +188,7 @@ def minimize_bfgs(func, x0, jac=None, maxiter=None, norm=mnp.inf, gtol=1e-5, lin
         BFGSResults, results from BFGS optimization.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
     """
     if jac is None:
         jac = grad(func)

mindspore/scipy/optimize/_lagrange.py

@@ -0,0 +1,200 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Lagrange"""
+import sys
+from typing import NamedTuple
+import numpy as np
+import mindspore as ms
+from mindspore import nn, ops, Parameter, Tensor, numpy as mnp
+from mindspore.nn import Cell
+from mindspore.scipy.utils import _to_scalar
+
+
+class _LagrangeResults(NamedTuple):
+    """Object holding optimization results.
+
+    Args:
+        succeeded (bool): return true if the solution satisfies the all constrains with respect to save_tol.
+        best_value (Tensor): best solution, has the same shape with x0.
+        object_value (float): the value of objective function at best_value.
+        loss_value (Tensor): the value of constrain functions at best_value.
+    """
+    succeeded: bool
+    best_value: float
+    object_value: float
+    loss_value: Tensor
+
+
+class AugmentLagrangeMethod(Cell):
+    """minimize lagrange"""
+
+    def __init__(self, objective_func, param, lower, upper, obj_weight, cons_num, constraints, coincide_fun, bound_val):
+        """Initialize Minimize lagrange."""
+        super(AugmentLagrangeMethod, self).__init__()
+        self.objective_func = objective_func
+        self.cons_num = cons_num
+        self.sigmoid = ops.Sigmoid()
+        self.relu = nn.ReLU()
+        self.pow = ops.Pow()
+        self.bound_val = bound_val
+        self.pow_rate = Tensor(2.0)
+        self.pow_rate_1 = Tensor(0.5)
+        if lower is not None:
+            self.lb = Tensor(lower)
+        if upper is not None:
+            self.ub = Tensor(upper)
+        self.param = Parameter(param)
+        self.obj_weight = Tensor(obj_weight)
+        self.sigma_k = Parameter(Tensor(1.0), requires_grad=False)
+        self.alpha = Tensor(0.1)
+        self.beta = Tensor(0.9)
+        self.epsilon_k = Parameter(1.0 / self.pow(self.sigma_k, self.alpha), requires_grad=False)
+        self.eta_k = Parameter(1.0 / self.sigma_k, requires_grad=False)
+        self.rho = Tensor(1.1)
+        self.constrain = constraints
+        self.mul_k = Parameter(mnp.ones((cons_num,), dtype=ms.float32), requires_grad=False)
+        self.loss_list = Parameter(mnp.ones((cons_num,), dtype=ms.float32), requires_grad=False)
+        self.object_value = Parameter(Tensor(1.0), requires_grad=False)
+        self.best_value = Parameter(param, requires_grad=False)
+        self.coincide_fun = coincide_fun
+
+
+    def normalize(self, x):
+        """normalize the input_x."""
+        if self.bound_val == 0:
+            return x
+        if self.bound_val == 1:
+            return (-x) * x + self.ub
+        if self.bound_val == 2:
+            return x * x + self.lb
+        return (self.ub - self.lb) * self.sigmoid(x) + self.lb
+
+
+    def get_loss(self, x):
+        """get the loss of function."""
+        x = self.normalize(x)
+        pernalty_func = 0
+        if self.coincide_fun is not None:
+            tmp_res = self.coincide_fun(x)
+            for i in range(self.cons_num):
+                cons = self.constrain[i]
+                self.loss_list[i] = cons(x, tmp_res)
+                pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\
+                    - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)
+                pernalty_func += pernalty_tmp
+            objective_val = self.objective_func(x, tmp_res)
+        else:
+            for i in range(self.cons_num):
+                cons = self.constrain[i]
+                self.loss_list[i] = cons(x)
+                pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\
+                    - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)
+                pernalty_func += pernalty_tmp
+            objective_val = self.objective_func(x)
+        loss1 = self.obj_weight * objective_val
+        lagrangian_func = loss1 + self.sigma_k / 2 * pernalty_func
+        res = [lagrangian_func, self.loss_list, objective_val, x]
+        return res
+
+
+    def update_param(self):
+        """update the parameter."""
+        v_k = 0
+        for i in range(self.cons_num):
+            v_k_i = self.pow(max(self.loss_list[i], -self.mul_k[i] / self.sigma_k), self.pow_rate)
+            v_k = v_k + v_k_i
+        v_k = self.pow(v_k, self.pow_rate_1)
+        if v_k <= self.epsilon_k:
+            for i in range(self.cons_num):
+                self.mul_k[i] = max(self.mul_k[i] + self.sigma_k * self.loss_list[i], 0)
+            self.eta_k = self.eta_k / self.sigma_k
+            self.epsilon_k = min(self.epsilon_k / (self.sigma_k ** self.beta), sys.float_info.max)
+        else:
+            self.sigma_k = self.rho * self.sigma_k
+            self.eta_k = 1.0 / self.sigma_k
+            self.epsilon_k = 1.0 / (self.sigma_k ** self.alpha)
+
+
+    def construct(self, x):
+        res = self.get_loss(self.param)
+        lang_func, self.loss_list, self.object_value, self.best_value = res
+        x = x * lang_func
+        return x
+
+
+class Loss(Cell):
+    """compute loss from data and label"""
+    def __init__(self):
+        """Initialize the loss."""
+        super(Loss, self).__init__()
+
+    def construct(self, data, label):
+        diff = data - label
+        return diff
+
+
+def check_tol(f0, object_value, save_tol, loss_list):
+    """check tolerance."""
+    chk_res = False
+    if (np.array(loss_list) - save_tol).max() < 0 and object_value < f0:
+        chk_res = True
+    return chk_res
+
+
+def minimize_lagrange(func, x0, constraints, save_tol=None, obj_weight=1.0, lower=None, upper=None,
+                      learning_rate=0.1, coincide_fun=None, rounds=10, steps=1000, log_sw=False):
+    """minimize lagrange."""
+    cons_num = len(constraints)
+    if lower is None and upper is None:
+        bound_val = 0
+    elif lower is None and upper is not None:
+        bound_val = 1
+    elif lower is not None and upper is None:
+        bound_val = 2
+    else:
+        bound_val = 3
+
+    net = AugmentLagrangeMethod(func, x0, lower, upper, obj_weight, cons_num, constraints, coincide_fun, bound_val)
+    loss = Loss()
+    optimizer = nn.Adam(params=net.trainable_params(), learning_rate=learning_rate, use_locking=True,
+                                                use_nesterov=False)
+    loss_net = nn.WithLossCell(net, loss)
+    label = Tensor(0.0, ms.float32)
+    image = Tensor(1.0, ms.float32)
+    train_net = nn.TrainOneStepCell(loss_net, optimizer)
+    f0 = 0
+    best_value = x0.asnumpy()
+    chk_res = False
+    loss_list = mnp.ones((cons_num,), dtype=ms.float32)
+    if save_tol is None:
+        save_tol = mnp.ones((cons_num,), dtype=ms.float32)
+    for j in range(rounds):
+        for i in range(steps):
+            lang_val = train_net(image, label)
+            if log_sw:
+                print(F"round:{j}, step:{i}")
+                print(F"object_value:{net.object_value.value()}, loss_value:{net.loss_list.value()}, \
+                            lagrange_value:{lang_val}")
+            if i == 0 and j == 0:
+                f0 = net.object_value.value().asnumpy()
+            chkres = check_tol(f0, net.object_value.value().asnumpy(), save_tol, net.loss_list.value().asnumpy())
+            if chkres:
+                chk_res = True
+                loss_list = net.loss_list.value().asnumpy()
+                best_value = net.best_value.value().asnumpy()
+                f0 = net.object_value.value().asnumpy()
+        net.update_param()
+    res = _LagrangeResults(succeeded=_to_scalar(chk_res), best_value=best_value, object_value=f0, loss_value=loss_list)
+    return res

mindspore/scipy/optimize/line_search.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """line search"""
 from typing import NamedTuple
+from mindspore import ops
 from ... import nn
 from ... import numpy as mnp
 from ...common import dtype as mstype
@@ -151,7 +152,7 @@ def _zoom(fn, a_low, phi_low, dphi_low, a_high, phi_high, dphi_high, phi_0, g_0,
         state["phi_high"] = mnp.where(j_to_high, phi_j, state["phi_high"])
         state["dphi_high"] = mnp.where(j_to_high, dphi_j, state["dphi_high"])
 
-        j_to_star = mnp.logical_not(j_to_high) and mnp.abs(dphi_j) <= -c2 * dphi_0
+        j_to_star = mnp.logical_not(j_to_high) and mnp.abs(dphi_j) <= ops.negative(ops.add(c2, Tensor(0))) * dphi_0
         state["done"] = j_to_star
         state["a_star"] = mnp.where(j_to_star, a_j, state["a_star"])
         state["phi_star"] = mnp.where(j_to_star, phi_j, state["phi_star"])
@@ -326,7 +327,7 @@ def line_search(f, xk, pk, jac=None, gfk=None, old_fval=None, old_old_fval=None,
         LineSearchResults, results of line search results.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp