scipy.optimize.

fmin_cobyla#

scipy.optimize.fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0, rhoend=0.0001, maxfun=1000, disp=None, catol=0.0002, *, callback=None)[Quelle]#

Minimiert eine Funktion mit der Methode Constrained Optimization By Linear Approximation (COBYLA). Diese Methode verwendet die reine Python-Implementierung des Algorithmus von PRIMA.

Parameter:

funccallable: Zu minimierende Funktion. Im Format func(x, *args).
x0ndarray: Anfangsschätzung.
consSequenz: Constraint-Funktionen; müssen alle >=0 sein (eine einzelne Funktion, wenn nur 1 Constraint). Jede Funktion nimmt die Parameter x als erstes Argument und kann entweder eine einzelne Zahl oder ein Array oder eine Liste von Zahlen zurückgeben.
argstuple, optional: Zusätzliche Argumente, die an die Funktion übergeben werden.
consargsTupel, optional: Zusätzliche Argumente, die an die Constraint-Funktionen übergeben werden (Standardwert None bedeutet, die gleichen zusätzlichen Argumente wie für func zu verwenden). Verwenden Sie () für keine zusätzlichen Argumente.
rhobegFloat, optional: Angemessene anfängliche Änderungen der Variablen.
rhoendFloat, optional: Endgültige Genauigkeit bei der Optimierung (nicht exakt garantiert). Dies ist eine untere Schranke für die Größe der Vertrauensregion.
disp{0, 1, 2, 3}, optional: Steuert die Häufigkeit der Ausgabe; 0 bedeutet keine Ausgabe.
maxfunint, optional: Maximale Anzahl von Funktionsauswertungen.
catolFloat, optional: Absolute Toleranz für Constraint-Verletzungen.
callbackcallable, optional: Wird nach jeder Iteration aufgerufen, als callback(x), wobei x der aktuelle Parametervektor ist.

Rückgabe:

xndarray: Das Argument, das f minimiert.

Siehe auch

minimieren: Schnittstelle zu Minimierungsalgorithmen für multivariate Funktionen. Siehe insbesondere die Methode ‚COBYLA‘.

Hinweise

Dieser Algorithmus basiert auf linearen Approximationen der Zielfunktion und jedes Constraints. Wir beschreiben den Algorithmus kurz.

Angenommen, die Funktion wird über k Variablen minimiert. Bei der j-ten Iteration verfügt der Algorithmus über k+1 Punkte v_1, ..., v_(k+1), eine ungefähre Lösung x_j und einen Radius RHO_j. (d.h. lineare plus eine konstante) Approximationen der Zielfunktion und der Constraint-Funktionen, sodass ihre Funktionswerte mit der linearen Approximation an den k+1 Punkten v_1, ..., v_(k+1) übereinstimmen. Dies ergibt ein lineares Programm zur Lösung (bei dem die linearen Approximationen der Constraint-Funktionen nicht-negativ sein müssen).

Die linearen Approximationen sind jedoch wahrscheinlich nur gute Annäherungen in der Nähe des aktuellen Simplex, daher erhält das lineare Programm die zusätzliche Anforderung, dass die Lösung, die zu x_(j+1) wird, innerhalb von RHO_j von x_j liegen muss. RHO_j nimmt nur ab, niemals zu. Das anfängliche RHO_j ist rhobeg und das endgültige RHO_j ist rhoend. Auf diese Weise verhalten sich die Iterationen von COBYLA wie ein Trust-Region-Algorithmus.

Zusätzlich kann das lineare Programm inkonsistent sein oder die Approximation kann eine schlechte Verbesserung ergeben. Details zur Lösung dieser Probleme und zur Aktualisierung der Punkte v_i finden Sie im Quellcode oder in den unten aufgeführten Referenzen.

Geändert in Version 1.16.0: Die ursprüngliche Implementierung von Powell wurde durch eine reine Python-Version aus dem PRIMA-Paket ersetzt, mit Fehlerbehebungen und Verbesserungen.

Referenzen

Powell M.J.D. (1994), „A direct search optimization method that models the objective and constraint functions by linear interpolation.“, in Advances in Optimization and Numerical Analysis, Hrsg. S. Gomez und J-P Hennart, Kluwer Academic (Dordrecht), S. 51-67

Powell M.J.D. (1998), „Direct search algorithms for optimization calculations“, Acta Numerica 7, 287-336

Powell M.J.D. (2007), „A view of algorithms for optimization without derivatives“, Cambridge University Technical Report DAMTP 2007/NA03

Zhang Z. (2023), „PRIMA: Reference Implementation for Powell’s Methods with Modernization and Amelioration“, https://www.libprima.net, DOI:10.5281/zenodo.8052654

Beispiele

Minimieren Sie die Zielfunktion f(x,y) = x*y unter den Nebenbedingungen x**2 + y**2 < 1 und y > 0

>>> 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])

Die exakte Lösung ist (-sqrt(2)/2, sqrt(2)/2).