Document

scipy 1.8.0 Pypi GitHub Homepage

fmin_bfgs(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None)

Notes

Optimize the function, f, whose gradient is given by fprime using the quasi-Newton method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS).

Parameters

f : callable ``f(x,*args)``: Objective function to be minimized.
x0 : ndarray: Initial guess.
fprime : callable ``f'(x,*args)``, optional: Gradient of f.
args : tuple, optional: Extra arguments passed to f and fprime.
gtol : float, optional: Gradient norm must be less than :None:None:`gtol` before successful termination.
norm : float, optional: Order of norm (Inf is max, -Inf is min)
epsilon : int or ndarray, optional: If fprime is approximated, use this value for the step size.
callback : callable, optional: An optional user-supplied function to call after each iteration. Called as callback(xk) , where xk is the current parameter vector.
maxiter : int, optional: Maximum number of iterations to perform.
full_output : bool, optional: If True, return fopt , func_calls , grad_calls , and warnflag in addition to xopt .
disp : bool, optional: Print convergence message if True.
retall : bool, optional: Return a list of results at each iteration if True.

Returns

xopt : ndarray: Parameters which minimize f, i.e., f(xopt) == fopt .
fopt : float: Minimum value.
gopt : ndarray: Value of gradient at minimum, f'(xopt), which should be near 0.
Bopt : ndarray: Value of 1/f''(xopt), i.e., the inverse Hessian matrix.
func_calls : int: Number of function_calls made.
grad_calls : int: Number of gradient calls made.
warnflag : integer
allvecs : list: The value of :None:None:`xopt` at each iteration. Only returned if :None:None:`retall` is True.

Minimize a function using the BFGS algorithm.

Examples

>>> from scipy.optimize import fmin_bfgs
... def quadratic_cost(x, Q):
...     return x @ Q @ x
...

>>> x0 = np.array([-3, -4])
... cost_weight =  np.diag([1., 10.])
... # Note that a trailing comma is necessary for a tuple with single element
... fmin_bfgs(quadratic_cost, x0, args=(cost_weight,))
Optimization terminated successfully.
        Current function value: 0.000000
        Iterations: 7                   # may vary
        Function evaluations: 24        # may vary
        Gradient evaluations: 8         # may vary
array([ 2.85169950e-06, -4.61820139e-07])

>>> def quadratic_cost_grad(x, Q):
...     return 2 * Q @ x
...

>>> fmin_bfgs(quadratic_cost, x0, quadratic_cost_grad, args=(cost_weight,))
Optimization terminated successfully.
        Current function value: 0.000000
        Iterations: 7
        Function evaluations: 8
        Gradient evaluations: 8
array([ 2.85916637e-06, -4.54371951e-07])

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

scipy.optimize._optimize.fmin_bfgs scipy.optimize._optimize.approx_fprime

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