fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0, rhoend=0.0001, maxfun=1000, disp=None, catol=0.0002, *, callback=None)

Notes

This algorithm is based on linear approximations to the objective function and each constraint. We briefly describe the algorithm.

Suppose the function is being minimized over k variables. At the jth iteration the algorithm has k+1 points v_1, ..., v_(k+1), an approximate solution x_j, and a radius RHO_j. (i.e., linear plus a constant) approximations to the objective function and constraint functions such that their function values agree with the linear approximation on the k+1 points v_1,.., v_(k+1). This gives a linear program to solve (where the linear approximations of the constraint functions are constrained to be non-negative).

However, the linear approximations are likely only good approximations near the current simplex, so the linear program is given the further requirement that the solution, which will become x_(j+1), must be within RHO_j from x_j. RHO_j only decreases, never increases. The initial RHO_j is rhobeg and the final RHO_j is rhoend. In this way COBYLA's iterations behave like a trust region algorithm.

Additionally, the linear program may be inconsistent, or the approximation may give poor improvement. For details about how these issues are resolved, as well as how the points v_i are updated, refer to the source code or the references below.

Parameters

func : callable

Function to minimize. In the form func(x, \*args).

x0 : ndarray

Initial guess.

cons : sequence

Constraint functions; must all be >=0 (a single function if only 1 constraint). Each function takes the parameters x as its first argument, and it can return either a single number or an array or list of numbers.

args : tuple, optional

Extra arguments to pass to function.

consargs : tuple, optional

Extra arguments to pass to constraint functions (default of None means use same extra arguments as those passed to func). Use () for no extra arguments.

rhobeg : float, optional

Reasonable initial changes to the variables.

rhoend : float, optional

Final accuracy in the optimization (not precisely guaranteed). This is a lower bound on the size of the trust region.

disp : {0, 1, 2, 3}, optional

Controls the frequency of output; 0 implies no output.

maxfun : int, optional

Maximum number of function evaluations.

catol : float, optional

Absolute tolerance for constraint violations.

callback : callable, optional

Called after each iteration, as callback(x) , where x is the current parameter vector.

Returns

x : ndarray

The argument that minimises f.

Minimize a function using the Constrained Optimization By Linear Approximation (COBYLA) method. This method wraps a FORTRAN implementation of the algorithm.

See Also

minimize

Interface to minimization algorithms for multivariate functions. See the 'COBYLA' :None:None:`method` in particular.

Examples

>>> def objective(x):
...     return x[0]*x[1]
...
>>> def constr1(x):
...     return 1 - (x[0]**2 + x[1]**2)
...
>>> def constr2(x):
...     return x[1]
...
>>> from scipy.optimize import fmin_cobyla
>>> fmin_cobyla(objective, [0.0, 0.1], [constr1, constr2], rhoend=1e-7)
array([-0.70710685,  0.70710671])

The exact solution is (-sqrt(2)/2, sqrt(2)/2).

See :

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /scipy/optimize/_cobyla_py.py#37
type: <class 'function'>
Commit: