scipy.optimize.

fmin_l_bfgs_b#

scipy.optimize.fmin_l_bfgs_b(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, m=10, factr=10000000.0, pgtol=1e-05, epsilon=1e-08, iprint=<object object>, maxfun=15000, maxiter=15000, disp=<object object>, callback=None, maxls=20)[Quelle]#

Minimiere eine Funktion func mit dem L-BFGS-B-Algorithmus.

Parameter:
funccallable f(x,*args)

Zu minimierende Funktion.

x0ndarray

Anfangsschätzung.

fprimecallable fprime(x,*args), optional

Der Gradient von func. Wenn None, dann gibt func den Funktionswert und den Gradienten zurück (f, g = func(x, *args)), es sei denn, approx_grad ist True, in welchem Fall func nur f zurückgibt.

argssequence, optional

Argumente, die an func und fprime übergeben werden sollen.

approx_gradbool, optional

Ob der Gradient numerisch approximiert werden soll (in diesem Fall gibt func nur den Funktionswert zurück).

boundslist, optional

(min, max) Paare für jedes Element in x, die die Grenzen für diesen Parameter definieren. Verwenden Sie None oder +-inf für eine der Grenzen min oder max, wenn keine Grenze in dieser Richtung vorhanden ist.

mint, optional

Die maximale Anzahl von variablen Metrik-Korrekturen, die zur Definition der Limit-Memory-Matrix verwendet werden. (Die Limited-Memory-BFGS-Methode speichert nicht die volle Hesse-Matrix, sondern verwendet diese Anzahl von Termen in einer Approximation davon.)

factrfloat, optional

Die Iteration stoppt, wenn (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps ist, wobei eps die Maschinenpräzision ist, die automatisch vom Code generiert wird. Typische Werte für factr sind: 1e12 für geringe Genauigkeit; 1e7 für moderate Genauigkeit; 10.0 für extrem hohe Genauigkeit. Siehe Hinweise für die Beziehung zu ftol, die (anstelle von factr) von der scipy.optimize.minimize Schnittstelle zu L-BFGS-B bereitgestellt wird.

pgtolfloat, optional

Die Iteration stoppt, wenn max{|proj g_i | i = 1, ..., n} <= pgtol ist, wobei proj g_i die i-te Komponente des projizierten Gradienten ist.

epsilonfloat, optional

Schrittgröße, die bei `approx_grad=True` zur numerischen Berechnung des Gradienten verwendet wird.

iprintint, optional

Veraltete Option, die zuvor den auf dem Bildschirm während der Problemlösung ausgegebenen Text steuerte. Jetzt gibt der Code keine Ausgabe mehr aus und dieses Schlüsselwort hat keine Funktion.

Seit Version 1.15.0 veraltet: Dieses Schlüsselwort ist veraltet und wird aus SciPy 1.18.0 entfernt.

dispint, optional

Veraltete Option, die zuvor den auf dem Bildschirm während der Problemlösung ausgegebenen Text steuerte. Jetzt gibt der Code keine Ausgabe mehr aus und dieses Schlüsselwort hat keine Funktion.

Seit Version 1.15.0 veraltet: Dieses Schlüsselwort ist veraltet und wird aus SciPy 1.18.0 entfernt.

maxfunint, optional

Maximale Anzahl von Funktionsauswertungen. Beachten Sie, dass diese Funktion das Limit verletzen kann, da die Gradienten mittels numerischer Differenzierung ausgewertet werden.

maxiterint, optional

Maximale Anzahl von Iterationen.

callbackcallable, optional

Wird nach jeder Iteration aufgerufen als callback(xk), wobei xk der aktuelle Parametervektor ist.

maxlsint, optional

Maximale Anzahl von Schrittweiten-Suchläufen (pro Iteration). Standard ist 20.

Rückgabe:
xarray_like

Geschätzte Position des Minimums.

ffloat

Wert von func am Minimum.

ddict

Informations-Dictionary.

  • d[‘warnflag’] ist

    • 0 bei Konvergenz,

    • 1 bei zu vielen Funktionsauswertungen oder zu vielen Iterationen,

    • 2 bei Abbruch aus einem anderen Grund, angegeben in d[‘task’]

  • d[‘grad’] ist der Gradient am Minimum (sollte nahe 0 sein)

  • d[‘funcalls’] ist die Anzahl der durchgeführten Funktionsaufrufe.

  • d[‘nit’] ist die Anzahl der Iterationen.

Siehe auch

minimieren

Schnittstelle zu Minimierungsalgorithmen für multivariate Funktionen. Beachten Sie insbesondere die Methode 'L-BFGS-B'. Beachten Sie, dass die Option ftol über diese Schnittstelle verfügbar ist, während factr über diese Schnittstelle bereitgestellt wird, wobei factr der Faktor ist, der die Standard-Maschinen-Gleitkommapräzision multipliziert, um ftol zu erhalten: ftol = factr * numpy.finfo(float).eps.

Hinweise

SciPy verwendet eine in C übersetzte und modifizierte Version des Fortran-Codes L-BFGS-B v3.0 (veröffentlicht am 25. April 2011, BSD-3-lizenziert). Die ursprüngliche Fortran-Version wurde von Ciyou Zhu, Richard Byrd, Jorge Nocedal und Jose Luis Morales geschrieben.

Referenzen

  • R. H. Byrd, P. Lu und J. Nocedal. A Limited Memory Algorithm for Bound Constrained Optimization, (1995), SIAM Journal on Scientific and Statistical Computing, 16, 5, S. 1190-1208.

  • C. Zhu, R. H. Byrd und J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (1997), ACM Transactions on Mathematical Software, 23, 4, S. 550 - 560.

  • J.L. Morales und J. Nocedal. L-BFGS-B: Remark on Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (2011), ACM Transactions on Mathematical Software, 38, 1.

Beispiele

Löse ein lineares Regressionsproblem mittels fmin_l_bfgs_b. Dazu definieren wir zunächst eine Zielfunktion f(m, b) = (y - y_model)**2, wobei y die Beobachtungen beschreibt und y_model die Vorhersage des linearen Modells als y_model = m*x + b. Die Grenzen für die Parameter m und b werden für dieses Beispiel willkürlich als (0,5) und (5,10) gewählt.

>>> import numpy as np
>>> from scipy.optimize import fmin_l_bfgs_b
>>> X = np.arange(0, 10, 1)
>>> M = 2
>>> B = 3
>>> Y = M * X + B
>>> def func(parameters, *args):
...     x = args[0]
...     y = args[1]
...     m, b = parameters
...     y_model = m*x + b
...     error = sum(np.power((y - y_model), 2))
...     return error

>>> initial_values = np.array([0.0, 1.0])

>>> x_opt, f_opt, info = fmin_l_bfgs_b(func, x0=initial_values, args=(X, Y),
...                                    approx_grad=True)
>>> x_opt, f_opt
array([1.99999999, 3.00000006]), 1.7746231151323805e-14  # may vary

Die optimierten Parameter in x_opt stimmen mit den Ground-Truth-Parametern m und b überein. Als Nächstes führen wir eine grenz_beschränkte Optimierung mit dem Parameter bounds durch.

>>> bounds = [(0, 5), (5, 10)]
>>> x_opt, f_op, info = fmin_l_bfgs_b(func, x0=initial_values, args=(X, Y),
...                                   approx_grad=True, bounds=bounds)
>>> x_opt, f_opt
array([1.65990508, 5.31649385]), 15.721334516453945  # may vary
Auf dieser Seite