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)[source]
Minimization of scalar function of one or more variables.
This API for this function matches SciPy with some minor deviations:
Gradients of
funcare calculated automatically using MindSpore’s autodiff support when the value of jac is None.The
methodargument 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,
x0 (Tensor) – initial guess. Array of real elements of size
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: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.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:
GPUCPU
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.]
