mindspore.scipy.optimize.minimize

mindspore.scipy.optimize.minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)

Minimization of scalar function of one or more variables.

This API for this function matches SciPy with some minor deviations:

• 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” in the SciPy interface have not yet been implemented.

• Optimization results may differ from SciPy due to differences in the line search implementation.

Note

• minimize does not yet support differentiation or arguments in the form of multi-dimensional Tensor, but support for both is planned.

• minimize is not supported on Windows platform yet.

• LAGRANGE method is only supported on “GPU”.

Parameters

• func (Callable) – the objective function to be minimized, \(fun(x, *args) -> float\), where x is a 1-D array with shape \((n,)\) and args is a tuple of the fixed parameters needed to completely specify the function. fun must support differentiation if jac is None.

• x0 (Tensor) – initial guess. Array of real elements of size \((n,)\), where n is the number of independent variables.

• args (Tuple) – extra arguments passed to the objective function. Default: () .

• method (The follow options are exclusive to Lagrange) – 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: \(jac(x, *args) -> array\_like, shape (n,)\) where x is an array with shape \((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.

• 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:

GPU CPU

Examples

>>> import numpy as onp
>>> from mindspore.scipy.optimize import minimize
>>> 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
>>> res = minimize(func, x0, method='BFGS', 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.]