scipy.optimize.

NonlinearConstraint#

class scipy.optimize.NonlinearConstraint(fun, lb, ub, jac='2-point', hess=None, keep_feasible=False, finite_diff_rel_step=None, finite_diff_jac_sparsity=None)[Quelle]#

Nichtlineare Einschränkung der Variablen.

Die Nebenbedingung hat die allgemeine Ungleichungsform

lb <= fun(x) <= ub

Hier wird der Vektor der unabhängigen Variablen x als ndarray der Form (n,) übergeben und fun gibt einen Vektor mit m Komponenten zurück.

Es ist möglich, gleiche Grenzen zu verwenden, um eine Gleichheitsnebenbedingung darzustellen, oder unendliche Grenzen, um eine einseitige Nebenbedingung darzustellen.

Parameter:
funcallable

Die Funktion, die die Einschränkung definiert. Die Signatur ist fun(x) -> array_like, shape (m,).

lb, ubarray_like

Untere und obere Schranken für die Einschränkung. Jedes Array muss die Form (m,) haben oder ein Skalar sein, in letzterem Fall ist eine Schranke für alle Komponenten der Einschränkung gleich. Verwenden Sie np.inf mit entsprechendem Vorzeichen, um eine einseitige Einschränkung anzugeben. Setzen Sie Komponenten von lb und ub gleich, um eine Gleichheitseinschränkung darzustellen. Beachten Sie, dass Sie Einschränkungen verschiedener Typen mischen können: Intervall-, einseitige oder Gleichheitseinschränkungen, indem Sie verschiedene Komponenten von lb und ub nach Bedarf setzen.

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

Methode zur Berechnung der Jacobi-Matrix (eine m-mal-n-Matrix, wobei das Element (i, j) die partielle Ableitung von f[i] nach x[j] ist). Die Schlüsselwörter {‘2-point’, ‘3-point’, ‘cs’} wählen ein Schema für endliche Differenzen zur numerischen Schätzung aus. Eine aufrufbare Funktion muss die folgende Signatur haben

jac(x) -> {ndarray, sparse array}, shape (m, n)

Standard ist ‘2-point’.

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

Methode zur Berechnung der Hesse-Matrix. Die Schlüsselwörter {‘2-point’, ‘3-point’, ‘cs’} wählen ein Schema für endliche Differenzen zur numerischen Schätzung aus. Alternativ können Objekte, die die HessianUpdateStrategy-Schnittstelle implementieren, zur Annäherung der Hesse-Matrix verwendet werden. Derzeit verfügbare Implementierungen sind

Eine aufrufbare Funktion muss die Hesse-Matrix von dot(fun, v) zurückgeben und muss die folgende Signatur haben: hess(x, v) -> {LinearOperator, sparse array, array_like}, shape (n, n). Hier ist v ein ndarray mit der Form (m,) und enthält Lagrange-Multiplikatoren.

keep_feasiblearray_like of bool, optional

Ob die Einschränkungskomponenten während der Iterationen als zulässig beibehalten werden sollen. Ein einzelner Wert setzt diese Eigenschaft für alle Komponenten. Standard ist False. Hat keine Auswirkung auf Gleichheitseinschränkungen.

finite_diff_rel_step: None oder array_like, optional

Relative Schrittgröße für die Annäherung durch endliche Differenzen. Standard ist None, was automatisch einen angemessenen Wert in Abhängigkeit vom Schema für endliche Differenzen wählt.

finite_diff_jac_sparsity: {None, array_like, sparse array}, optional

Definiert die Sparsity-Struktur der Jacobi-Matrix für die Schätzung durch endliche Differenzen, ihre Form muss (m, n) sein. Wenn die Jacobi-Matrix nur wenige Nicht-Null-Elemente in *jeder* Zeile hat, beschleunigt die Angabe der Sparsity-Struktur die Berechnungen erheblich. Ein Null-Eintrag bedeutet, dass ein entsprechender Eintrag in der Jacobi-Matrix identisch Null ist. Wenn angegeben, wird die Verwendung des Trust-Region-Solvers 'lsmr' erzwungen. Wenn None (Standard), werden dichte Differenzen verwendet.

Hinweise

Schemata für endliche Differenzen {‘2-point’, ‘3-point’, ‘cs’} können zur Annäherung der Jacobi-Matrix oder der Hesse-Matrix verwendet werden. Wir erlauben jedoch nicht deren gleichzeitige Verwendung für beide. Daher muss die Hesse-Matrix, wenn die Jacobi-Matrix mittels endlicher Differenzen geschätzt wird, mittels einer der Quasi-Newton-Strategien geschätzt werden.

Das Schema 'cs' ist potenziell am genauesten, erfordert jedoch, dass die Funktion komplexe Eingaben korrekt verarbeitet und analytisch in die komplexe Ebene fortgesetzt werden kann. Das Schema '3-point' ist genauer als '2-point', erfordert aber doppelt so viele Operationen.

Beispiele

Beschränke x[0] < sin(x[1]) + 1.9

>>> from scipy.optimize import NonlinearConstraint
>>> import numpy as np
>>> con = lambda x: x[0] - np.sin(x[1])
>>> nlc = NonlinearConstraint(con, -np.inf, 1.9)
Auf dieser Seite