scipy.optimize.

minimize#

scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)[Quelle]#

Minimierung einer skalaren Funktion von einer oder mehreren Variablen.

Parameter:
funcallable

Die zu minimierende Zielfunktion

fun(x, *args) -> float

wobei x ein 1-D-Array mit der Form (n,) ist und args ein Tupel fester Parameter ist, die zur vollständigen Spezifikation der Funktion erforderlich sind.

Angenommen, die aufrufbare Funktion hat die Signatur f0(x, *my_args, **my_kwargs), wobei my_args und my_kwargs erforderliche positionale und Keyword-Argumente sind. Anstatt f0 als aufrufbare Funktion zu übergeben, wrappen Sie sie so, dass nur x akzeptiert wird; z. B. übergeben Sie fun=lambda x: f0(x, *my_args, **my_kwargs) als aufrufbare Funktion, wobei my_args (Tupel) und my_kwargs (dict) vor dem Aufruf dieser Funktion gesammelt wurden.

x0ndarray, Form (n,)

Anfangsschätzung. Array von reellen Elementen der Größe (n,), wobei n die Anzahl der unabhängigen Variablen ist.

argstuple, optional

Zusätzliche Argumente, die an die Zielfunktion und ihre Ableitungen (fun, jac und hess Funktionen) übergeben werden.

methodstr oder aufrufbar, optional

Art des Lösers. Muss eine der folgenden sein:

Wenn nicht angegeben, wird einer von BFGS, L-BFGS-B, SLSQP gewählt, je nachdem, ob das Problem Einschränkungen oder Grenzen hat.

jac{callable, ‘2-point’, ‘3-point’, ‘cs’, bool}, optional

Methode zur Berechnung des Gradientenvektors. Nur für CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg, trust-krylov, trust-exact und trust-constr. Wenn es aufrufbar ist, sollte es eine Funktion sein, die den Gradientenvektor zurückgibt.

jac(x, *args) -> array_like, shape (n,)

wobei x ein Array der Form (n,) und args ein Tupel mit den festen Parametern ist. Wenn jac ein Boolescher Wert ist und True ist, wird angenommen, dass fun ein Tupel (f, g) zurückgibt, das die Zielfunktion und den Gradienten enthält. Die Methoden ‘Newton-CG’, ‘trust-ncg’, ‘dogleg’, ‘trust-exact’ und ‘trust-krylov’ erfordern entweder, dass eine aufrufbare Funktion übergeben wird, oder dass fun die Zielfunktion und den Gradienten zurückgibt. Wenn None oder False, wird der Gradient mittels 2-Punkt-Differenzenabschätzung mit einer absoluten Schrittgröße geschätzt. Alternativ können die Schlüsselwörter {‘2-point’, ‘3-point’, ‘cs’} verwendet werden, um ein Differenzenverfahren für die numerische Schätzung des Gradienten mit relativer Schrittgröße auszuwählen. Diese Differenzenverfahren befolgen alle angegebenen bounds.

hess{callable, ‘2-point’, ‘3-point’, ‘cs’, HessianUpdateStrategy}, optional

Methode zur Berechnung der Hesse-Matrix. Nur für Newton-CG, dogleg, trust-ncg, trust-krylov, trust-exact und trust-constr. Wenn es aufrufbar ist, sollte es die Hesse-Matrix zurückgeben.

hess(x, *args) -> {LinearOperator, spmatrix, array}, (n, n)

wobei x ein (n,) ndarray ist und args ein Tupel mit den festen Parametern ist. Die Schlüsselwörter {‘2-point’, ‘3-point’, ‘cs’} können auch verwendet werden, um ein Differenzenverfahren zur numerischen Schätzung der Hesse-Matrix auszuwählen. Alternativ können Objekte, die die HessianUpdateStrategy-Schnittstelle implementieren, zur Approximation der Hesse-Matrix verwendet werden. Verfügbare Quasi-Newton-Methoden, die diese Schnittstelle implementieren, sind

Nicht alle Optionen sind für jede Methode verfügbar. Informationen zur Verfügbarkeit finden Sie in den Hinweisen.

hesspcallable, optional

Hesse-Matrix der Zielfunktion mal einen beliebigen Vektor p. Nur für Newton-CG, trust-ncg, trust-krylov, trust-constr. Nur hessp oder hess muss angegeben werden. Wenn hess angegeben ist, wird hessp ignoriert. hessp muss die Hesse-Matrix mal einen beliebigen Vektor berechnen.

hessp(x, p, *args) ->  ndarray shape (n,)

wobei x ein (n,) ndarray ist, p ein beliebiger Vektor mit der Dimension (n,) ist und args ein Tupel mit den festen Parametern ist.

boundssequence oder Bounds, optional

Grenzen für Variablen für die Methoden Nelder-Mead, L-BFGS-B, TNC, SLSQP, Powell, trust-constr, COBYLA und COBYQA. Es gibt zwei Möglichkeiten, die Grenzen anzugeben.

  1. Instanz der Klasse Bounds.

  2. Sequenz von Paaren (min, max) für jedes Element in x. None wird verwendet, um keine Grenze anzugeben.

constraints{Constraint, dict} oder Liste von {Constraint, dict}, optional

Definition von Nebenbedingungen. Nur für COBYLA, COBYQA, SLSQP und trust-constr.

Nebenbedingungen für ‘trust-constr’, ‘cobyqa’ und ‘cobyla’ werden als einzelnes Objekt oder Liste von Objekten definiert, die die Nebenbedingungen für das Optimierungsproblem spezifizieren. Verfügbare Nebenbedingungen sind

Nebenbedingungen für COBYLA, SLSQP werden als Liste von Dictionaries definiert. Jedes Dictionary mit den Feldern

typestr

Nebenbedingungstyp: ‘eq’ für Gleichheit, ‘ineq’ für Ungleichheit.

funcallable

Die Funktion, die die Nebenbedingung definiert.

jaccallable, optional

Der Jacobitant von fun (nur für SLSQP).

argssequence, optional

Zusätzliche Argumente, die an die Funktion und den Jacobitant übergeben werden.

Gleichheitsnebenbedingung bedeutet, dass das Ergebnis der Nebenbedingungsfunktion Null sein soll, während Ungleichheitsnebenbedingung bedeutet, dass es nicht-negativ sein soll. Beachten Sie, dass COBYLA nur Ungleichheitsnebenbedingungen unterstützt.

tolfloat, optional

Toleranz für die Beendigung. Wenn tol angegeben ist, setzt der ausgewählte Minimierungsalgorithmus eine oder mehrere relevante solver-spezifische Toleranzen auf tol. Für detaillierte Kontrolle verwenden Sie solver-spezifische Optionen.

optionsdict, optional

Ein Dictionary mit Solver-Optionen. Alle Methoden außer TNC akzeptieren die folgenden generischen Optionen.

maxiterint

Maximale Anzahl der durchzuführenden Iterationen. Je nach Methode kann jede Iteration mehrere Funktionsauswertungen verwenden.

Für TNC verwenden Sie maxfun anstelle von maxiter.

dispbool

Auf True setzen, um Konvergenz-Meldungen auszugeben.

Für methodenspezifische Optionen siehe show_options.

callbackcallable, optional

Ein aufrufbares Objekt, das nach jeder Iteration aufgerufen wird.

Alle Methoden außer TNC und SLSQP unterstützen eine aufrufbare Funktion mit der Signatur

callback(intermediate_result: OptimizeResult)

wobei intermediate_result ein Schlüsselwortparameter ist, der ein OptimizeResult-Objekt mit den Attributen x und fun enthält, die aktuellen Werte des Parametervektors und der Zielfunktion. Nicht alle Attribute von OptimizeResult sind möglicherweise vorhanden. Der Name des Parameters muss intermediate_result sein, damit der Callback ein OptimizeResult erhält. Diese Methoden werden auch beendet, wenn der Callback StopIteration auslöst.

Alle Methoden außer trust-constr unterstützen (auch) eine Signatur wie

callback(xk)

wobei xk der aktuelle Parametervektor ist.

Introspektion wird verwendet, um zu bestimmen, welche der obigen Signaturen aufgerufen werden soll.

Rückgabe:
resOptimizeResult

Das Optimierungsergebnis, dargestellt als OptimizeResult-Objekt. Wichtige Attribute sind: x der Lösungsvektor, success ein boolesches Flag, das angibt, ob der Optimizer erfolgreich beendet wurde, und message, das die Ursache der Beendigung beschreibt. Siehe OptimizeResult für eine Beschreibung anderer Attribute.

Siehe auch

minimize_scalar

Schnittstelle zu Minimierungsalgorithmen für skalare univariate Funktionen

show_options

Zusätzliche Optionen, die von den Lösungsalgorithmen akzeptiert werden

Hinweise

Dieser Abschnitt beschreibt die verfügbaren Solver, die mit dem Parameter ‘method’ ausgewählt werden können. Die Standardmethode ist *BFGS*.

Unbeschränkte Minimierung

Die Methode CG verwendet einen nichtlinearen konjugierten Gradientenalgorithmus von Polak und Ribiere, eine Variante der Fletcher-Reeves-Methode, die in [5] pp.120-122 beschrieben ist. Nur die ersten Ableitungen werden verwendet.

Die Methode BFGS verwendet die Quasi-Newton-Methode von Broyden, Fletcher, Goldfarb und Shanno (BFGS) [5] pp. 136. Sie verwendet nur die ersten Ableitungen. BFGS hat sich auch bei nicht-glatten Optimierungen als leistungsfähig erwiesen. Diese Methode gibt auch eine Annäherung an die inverse Hesse-Matrix zurück, die als hess_inv im OptimizeResult-Objekt gespeichert ist.

Die Methode Newton-CG verwendet einen Newton-CG-Algorithmus [5] pp. 168 (auch bekannt als trunkierter Newton-Algorithmus). Er verwendet eine CG-Methode zur Berechnung der Suchrichtung. Siehe auch die Methode *TNC* für eine boxbeschränkte Minimierung mit einem ähnlichen Algorithmus. Geeignet für großskalige Probleme.

Die Methode dogleg verwendet den Trust-Region-Algorithmus Dogleg [5] für unbeschränkte Minimierung. Dieser Algorithmus erfordert den Gradienten und die Hesse-Matrix; darüber hinaus muss die Hesse-Matrix positiv definit sein.

Die Methode trust-ncg verwendet den Newton-konjugierten Gradienten-Trust-Region-Algorithmus [5] für unbeschränkte Minimierung. Dieser Algorithmus erfordert den Gradienten und entweder die Hesse-Matrix oder eine Funktion, die das Produkt der Hesse-Matrix mit einem gegebenen Vektor berechnet. Geeignet für großskalige Probleme.

Die Methode trust-krylov verwendet den Newton-GLTR-Trust-Region-Algorithmus [14], [15] für unbeschränkte Minimierung. Dieser Algorithmus erfordert den Gradienten und entweder die Hesse-Matrix oder eine Funktion, die das Produkt der Hesse-Matrix mit einem gegebenen Vektor berechnet. Geeignet für großskalige Probleme. Bei indefiniten Problemen benötigt er in der Regel weniger Iterationen als die Methode trust-ncg und wird für mittelgroße und großskalige Probleme empfohlen.

Die Methode trust-exact ist eine Trust-Region-Methode für unbeschränkte Minimierung, bei der quadratische Teilprobleme nahezu exakt gelöst werden [13]. Dieser Algorithmus erfordert den Gradienten und die Hesse-Matrix (die *nicht* positiv definit sein muss). In vielen Situationen ist er die Newton-Methode, die in weniger Iterationen konvergiert, und wird am meisten für kleine und mittelgroße Probleme empfohlen.

Beschränkte Minimierung

Die Methode Nelder-Mead verwendet den Simplex-Algorithmus [1], [2]. Dieser Algorithmus ist in vielen Anwendungen robust. Wenn jedoch die numerische Berechnung der Ableitung vertrauenswürdig ist, könnten andere Algorithmen, die Informationen der ersten und/oder zweiten Ableitung verwenden, aufgrund ihrer besseren Leistung im Allgemeinen bevorzugt werden.

Die Methode L-BFGS-B verwendet den L-BFGS-B-Algorithmus [6], [7] für die Minimierung mit beschränkten Variablen.

Die Methode Powell ist eine Modifikation von Powells Methode [3], [4], die eine Methode der konjugierten Richtungen ist. Sie führt sequenzielle eindimensionale Minimierungen entlang jeder Vektorrichtung des Richtungssets (direc Feld in options und info) durch, das bei jeder Iteration der Hauptminimierungsschleife aktualisiert wird. Die Funktion muss nicht differenzierbar sein und es werden keine Ableitungen verwendet. Wenn keine Grenzen angegeben sind, wird eine unbeschränkte Liniensuche verwendet. Wenn Grenzen angegeben sind und die Anfangsschätzung innerhalb der Grenzen liegt, dann wird jede Funktionsauswertung während des Minimierungsverfahrens innerhalb der Grenzen erfolgen. Wenn Grenzen angegeben sind, die Anfangsschätzung außerhalb der Grenzen liegt und direc vollen Rang hat (Standard ist voller Rang), dann können einige Funktionsauswertungen während der ersten Iteration außerhalb der Grenzen liegen, aber jede Funktionsauswertung nach der ersten Iteration wird innerhalb der Grenzen liegen. Wenn direc keinen vollen Rang hat, werden einige Parameter möglicherweise nicht optimiert und die Lösung liegt nicht garantiert innerhalb der Grenzen.

Die Methode TNC verwendet einen trunkierten Newton-Algorithmus [5], [8] zur Minimierung einer Funktion mit Variablen, die Grenzen unterliegen. Dieser Algorithmus verwendet Gradienteninformationen; er wird auch Newton-konjugierter Gradient genannt. Er unterscheidet sich von der oben beschriebenen Methode *Newton-CG*, da er eine C-Implementierung wrappt und es ermöglicht, jeder Variablen obere und untere Grenzen zuzuweisen.

Beschränkte Minimierung

Die Methode COBYLA verwendet die PRIMA-Implementierung [19] der Methode Constrained Optimization BY Linear Approximation (COBYLA) [9], [10], [11]. Der Algorithmus basiert auf linearen Approximationen der Zielfunktion und jeder Nebenbedingung.

Die Methode COBYQA verwendet die Methode Constrained Optimization BY Quadratic Approximations (COBYQA) [18]. Der Algorithmus ist eine derivative-freie Trust-Region-SQP-Methode, die auf quadratischen Approximationen der Zielfunktion und jeder nichtlinearen Nebenbedingung basiert. Die Grenzen werden als unverzichtbare Nebenbedingungen behandelt, d. h. der Algorithmus respektiert sie während des gesamten Optimierungsprozesses.

Die Methode SLSQP verwendet Sequential Least SQuares Programming, um eine Funktion mehrerer Variablen mit einer beliebigen Kombination von Grenzen, Gleichheits- und Ungleichheitsnebenbedingungen zu minimieren. Die Methode wrappt die SLSQP-Optimierungsroutine, die ursprünglich von Dieter Kraft implementiert wurde [12]. Beachten Sie, dass der Wrapper unendliche Werte in Grenzen verarbeitet, indem er sie in große Gleitkommazahlen umwandelt.

Die Methode trust-constr ist ein Trust-Region-Algorithmus für beschränkte Optimierung. Er wechselt je nach Problemdefinition zwischen zwei Implementierungen. Er ist der vielseitigste beschränkte Minimierungsalgorithmus, der in SciPy implementiert ist, und der am besten geeignete für großskalige Probleme. Für gleichheitsbeschränkte Probleme ist er eine Implementierung der Byrd-Omojokun Trust-Region SQP-Methode, die in [17] und in [5], S. 549, beschrieben ist. Wenn auch Ungleichheitsnebenbedingungen auferlegt werden, wechselt er zur Trust-Region-Interior-Point-Methode, die in [16] beschrieben ist. Dieser Interior-Point-Algorithmus löst Ungleichheitsnebenbedingungen, indem er Schlupfvariablen einführt und eine Folge von gleichheitsbeschränkten Barriereproblemen für progressiv kleinere Werte des Barriereparameters löst. Die zuvor beschriebene gleichheitsbeschränkte SQP-Methode wird verwendet, um die Teilprobleme mit zunehmendem Genauigkeitsgrad zu lösen, wenn sich die Iteration einer Lösung nähert.

Finite-Differenzen-Optionen

Für die Methode trust-constr können der Gradient und die Hesse-Matrix mithilfe von drei Differenzenverfahren approximiert werden: {‘2-point’, ‘3-point’, ‘cs’}. Das Schema ‘cs’ ist potenziell am genauesten, erfordert aber, dass die Funktion komplexe Eingaben korrekt verarbeitet und in der komplexen Ebene differenzierbar ist. Das Schema ‘3-point’ ist genauer als ‘2-point’, erfordert aber doppelt so viele Operationen. Wenn der Gradient mittels finiter Differenzen geschätzt wird, muss die Hesse-Matrix mithilfe einer der Quasi-Newton-Strategien geschätzt werden.

Methodenspezifische Optionen für den hess Schlüsselwortparameter

Methode/Hess

None

callable

‘2-point’/‘3-point’/‘cs’

HUS

Newton-CG

x

(n, n) LO

x

x

dogleg

(n, n)

trust-ncg

(n, n)

x

x

trust-krylov

(n, n)

x

x

trust-exact

(n, n)

trust-constr

x

(n, n) LO sp

x

x

wobei LO=LinearOperator, sp=Sparse matrix, HUS=HessianUpdateStrategy

Benutzerdefinierte Minimierer

Es kann nützlich sein, eine benutzerdefinierte Minimierungsmethode zu übergeben, zum Beispiel bei der Verwendung eines Frontends für diese Methode wie scipy.optimize.basinhopping oder einer anderen Bibliothek. Sie können einfach ein aufrufbares Objekt als Parameter method übergeben.

Das aufrufbare Objekt wird als method(fun, x0, args, **kwargs, **options) aufgerufen, wobei kwargs alle anderen an minimize übergebenen Parameter (wie callback, hess usw.) darstellt, außer dem options-Dictionary, dessen Inhalt ebenfalls paarweise als method-Parameter übergeben wird. Wenn jac als boolescher Typ übergeben wurde, werden jac und fun so manipuliert, dass fun nur die Funktionswerte zurückgibt und jac in eine Funktion umgewandelt wird, die den Jacobitant zurückgibt. Die Methode muss ein OptimizeResult-Objekt zurückgeben.

Das bereitgestellte method-Aufrufobjekt muss beliebige Parameter akzeptieren können (und möglicherweise ignorieren); die Menge der Parameter, die von minimize akzeptiert wird, kann in zukünftigen Versionen erweitert werden und diese Parameter werden dann an die Methode übergeben. Ein Beispiel finden Sie im SciPy-Optimierungs-Tutorial.

Referenzen

[1]

Nelder, J A, und R Mead. 1965. A Simplex Method for Function Minimization. The Computer Journal 7: 308-13.

[2]

Wright M H. 1996. Direct search methods: Once scorned, now respectable, in Numerical Analysis 1995: Proceedings of the 1995 Dundee Biennial Conference in Numerical Analysis (Eds. D F Griffiths und G A Watson). Addison Wesley Longman, Harlow, UK. 191-208.

[3]

Powell, M J D. 1964. An efficient method for finding the minimum of a function of several variables without calculating derivatives. The Computer Journal 7: 155-162.

[4]

Press W, S A Teukolsky, W T Vetterling und B P Flannery. Numerical Recipes (jede Ausgabe), Cambridge University Press.

[5] (1,2,3,4,5,6,7,8)

Nocedal, J, und S J Wright. 2006. Numerical Optimization. Springer New York.

[6]

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

[7]

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

[8]

Nash, S G. Newton-Type Minimization Via the Lanczos Method. 1984. SIAM Journal of Numerical Analysis 21: 770-778.

[9]

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

[10]

Powell M J D. Direct search algorithms for optimization calculations. 1998. Acta Numerica 7: 287-336.

[11]

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

[12]

Kraft, D. A software package for sequential quadratic programming. 1988. Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace Center – Institute for Flight Mechanics, Koln, Germany.

[13]

Conn, A. R., Gould, N. I., und Toint, P. L. Trust region methods. 2000. Siam. pp. 169-200.

[14]

F. Lenders, C. Kirches, A. Potschka: “trlib: A vector-free implementation of the GLTR method for iterative solution of the trust region problem”, arXiv:1611.04718

[15]

N. Gould, S. Lucidi, M. Roma, P. Toint: “Solving the Trust-Region Subproblem using the Lanczos Method”, SIAM J. Optim., 9(2), 504–525, (1999).

[16]

Byrd, Richard H., Mary E. Hribar, und Jorge Nocedal. 1999. An interior point algorithm for large-scale nonlinear programming. SIAM Journal on Optimization 9.4: 877-900.

[17]

Lalee, Marucha, Jorge Nocedal, und Todd Plantenga. 1998. On the implementation of an algorithm for large-scale equality constrained optimization. SIAM Journal on Optimization 8.3: 682-706.

[18]

Ragonneau, T. M. *Model-Based Derivative-Free Optimization Methods and Software*. PhD thesis, Department of Applied Mathematics, The Hong Kong Polytechnic University, Hong Kong, China, 2022. URL: https://theses.lib.polyu.edu.hk/handle/200/12294.

[19]

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

Beispiele

Betrachten wir das Problem der Minimierung der Rosenbrock-Funktion. Diese Funktion (und ihre entsprechenden Ableitungen) ist in rosen (bzw. rosen_der, rosen_hess) im Modul scipy.optimize implementiert.

>>> from scipy.optimize import minimize, rosen, rosen_der

Eine einfache Anwendung der *Nelder-Mead*-Methode ist

>>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]
>>> res = minimize(rosen, x0, method='Nelder-Mead', tol=1e-6)
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])

Nun unter Verwendung des *BFGS*-Algorithmus, der ersten Ableitung und einiger Optionen

>>> res = minimize(rosen, x0, method='BFGS', jac=rosen_der,
...                options={'gtol': 1e-6, 'disp': True})
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 26
         Function evaluations: 31
         Gradient evaluations: 31
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])
>>> print(res.message)
Optimization terminated successfully.
>>> res.hess_inv
array([
    [ 0.00749589,  0.01255155,  0.02396251,  0.04750988,  0.09495377],  # may vary
    [ 0.01255155,  0.02510441,  0.04794055,  0.09502834,  0.18996269],
    [ 0.02396251,  0.04794055,  0.09631614,  0.19092151,  0.38165151],
    [ 0.04750988,  0.09502834,  0.19092151,  0.38341252,  0.7664427 ],
    [ 0.09495377,  0.18996269,  0.38165151,  0.7664427,   1.53713523]
])

Betrachten wir als Nächstes ein Minimierungsproblem mit mehreren Nebenbedingungen (nämlich Beispiel 16.4 aus [5]). Die Zielfunktion ist

>>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2

Es gibt drei Nebenbedingungen, die wie folgt definiert sind:

>>> cons = ({'type': 'ineq', 'fun': lambda x:  x[0] - 2 * x[1] + 2},
...         {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6},
...         {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2})

Und Variablen müssen positiv sein, daher die folgenden Grenzen

>>> bnds = ((0, None), (0, None))

Das Optimierungsproblem wird mit der SLSQP-Methode gelöst, wie

>>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds, constraints=cons)

Es sollte zur theoretischen Lösung [1.4 ,1.7] konvergieren. SLSQP gibt auch die Multiplikatoren zurück, die bei der Lösung des Problems verwendet werden. Diese Multiplikatoren können, wenn die Nebenbedingungen des Problems linear sind, als Karush-Kuhn-Tucker (KKT)-Multiplikatoren betrachtet werden, die eine Verallgemeinerung von Lagrange-Multiplikatoren für Optimierungsprobleme mit Ungleichheitsnebenbedingungen darstellen ([20]).

Beachten Sie, dass am Lösungspunkt die erste Nebenbedingung aktiv ist. Werten wir die Funktion am Lösungspunkt aus

>>> cons[0]['fun'](res.x)
np.float64(1.4901224698604665e-09)

Beachten Sie auch, dass am Optimalpunkt ein von Null verschiedener Multiplikator vorhanden ist

>>> res.multipliers
array([0.8, 0. , 0. ])

Dies kann als die lokale Sensitivität des optimalen Werts der Zielfunktion gegenüber Änderungen der ersten Nebenbedingung verstanden werden. Wenn wir die Nebenbedingung um einen kleinen Betrag eps straffen

>>> eps = 0.01
>>> cons[0]['fun'] = lambda x: x[0] - 2 * x[1] + 2 - eps

erwarten wir, dass der optimale Wert der Zielfunktion um ungefähr eps * res.multipliers[0] steigt

>>> eps * res.multipliers[0]  # Expected change in f0
np.float64(0.008000000027153205)
>>> f0 = res.fun  # Keep track of the previous optimal value
>>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds, constraints=cons)
>>> f1 = res.fun  # New optimal value
>>> f1 - f0
np.float64(0.008019998807885509)
Auf dieser Seite