scipy.optimize.

fmin_bfgs#

scipy.optimize.fmin_bfgs(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=np.float64(1.4901161193847656e-08), maxiter=None, full_output=0, disp=1, retall=0, callback=None, xrtol=0, c1=0.0001, c2=0.9, hess_inv0=None)[Quelle]#

Minimiert eine Funktion mit dem BFGS-Algorithmus.

Parameter:
fcallable f(x,*args)

Zielfunktion, die minimiert werden soll.

x0ndarray

Anfangsschätzung, Form (n,)

fprimecallable f'(x,*args), optional

Gradient von f.

argstuple, optional

Zusätzliche Argumente, die an f und fprime übergeben werden.

gtolfloat, optional

Erfolgreiche Beendigung, wenn die Norm des Gradienten kleiner als gtol ist.

normfloat, optional

Ordnung der Norm (Inf ist Maximum, -Inf ist Minimum)

epsilonint oder ndarray, optional

Wenn fprime approximiert wird, wird dieser Wert für die Schrittgröße verwendet.

callbackcallable, optional

Eine optionale, vom Benutzer bereitgestellte Funktion, die nach jeder Iteration aufgerufen wird. Sie wird als callback(xk) aufgerufen, wobei xk der aktuelle Parametervektor ist.

maxiterint, optional

Maximale Anzahl durchzuführender Iterationen.

full_outputbool, optional

Wenn True, werden zusätzlich zu xopt auch fopt, func_calls, grad_calls und warnflag zurückgegeben.

dispbool, optional

Gibt die Konvergenznachricht aus, wenn True.

retallbool, optional

Gibt eine Liste der Ergebnisse bei jeder Iteration zurück, wenn True.

xrtolfloat, Standard: 0

Relative Toleranz für x. Beendet erfolgreich, wenn die Schrittgröße kleiner ist als xk * xrtol, wobei xk der aktuelle Parametervektor ist.

c1float, Standard: 1e-4

Parameter für die Armijo-Bedingungsregel.

c2float, Standard: 0.9

Parameter für die Krümmungsbedingungsregel.

hess_inv0None oder ndarray, optional``

Anfängliche Schätzung der inversen Hesse-Matrix, Form (n, n). Wenn None (Standard) wird die Einheitsmatrix verwendet.

Rückgabe:
xoptndarray

Parameter, die f minimieren, d.h. f(xopt) == fopt.

foptfloat

Minimaler Wert.

goptndarray

Wert des Gradienten am Minimum, f’(xopt), der nahe 0 sein sollte.

Boptndarray

Wert von 1/f’’(xopt), d.h. die inverse Hesse-Matrix.

func_callsint

Anzahl der durchgeführten Funktionsaufrufe.

grad_callsint

Anzahl der durchgeführten Gradientenaufrufe.

warnflaginteger

1 : Maximale Anzahl von Iterationen überschritten. 2 : Gradient und/oder Funktionsaufrufe ändern sich nicht. 3 : NaN-Ergebnis angetroffen.

allvecslist

Der Wert von xopt bei jeder Iteration. Wird nur zurückgegeben, wenn retall True ist.

Siehe auch

minimieren

Schnittstelle zu Minimierungsalgorithmen für multivariate Funktionen. Siehe insbesondere method='BFGS'.

Hinweise

Optimiert die Funktion f, deren Gradient durch fprime gegeben ist, unter Verwendung des Quasi-Newton-Verfahrens von Broyden, Fletcher, Goldfarb und Shanno (BFGS).

Die Parameter c1 und c2 müssen 0 < c1 < c2 < 1 erfüllen.

Referenzen

Wright und Nocedal, „Numerical Optimization“, 1999, S. 198.

Beispiele

>>> import numpy as np
>>> 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])
Auf dieser Seite