scipy.differentiate.

hessian#

scipy.differentiate.hessian(f, x, *, tolerances=None, maxiter=10, order=8, initial_step=0.5, step_factor=2.0)[Quelle]#

Evaluiert die Hesse-Matrix einer Funktion numerisch.

Parameter:

faufrufbar

Die Funktion, deren Hesse-Matrix gewünscht wird. Die Signatur muss sein

f(xi: ndarray) -> ndarray

wobei jedes Element von xi eine endliche reelle Zahl ist. Wenn die zu differenzierende Funktion zusätzliche Argumente akzeptiert, wickeln Sie sie ein (z. B. mit functools.partial oder lambda) und übergeben Sie die eingewickelte aufrufbare Funktion an hessian. f darf das Array xi nicht verändern. Siehe Hinweise zu Vektorisierung und Dimensionalität von Ein- und Ausgabe.

xFloat-Array-ähnlich

Punkte, an denen die Hesse-Matrix ausgewertet werden soll. Muss mindestens eine Dimension haben. Siehe Hinweise zur Dimensionalität und Vektorisierung.

tolerancesDictionary von Floats, optional

Absolute und relative Toleranzen. Gültige Schlüssel des Dictionaries sind

atol - absolute Toleranz für die Ableitung
rtol - relative Toleranz für die Ableitung

Die Iteration wird gestoppt, wenn res.error < atol + rtol * abs(res.df). Die Standardwerte für atol ist die kleinste normale Zahl des entsprechenden Datentyps, und der Standardwert für rtol ist die Quadratwurzel der Präzision des entsprechenden Datentyps.

orderInteger, Standard: 8

Die (positive ganze Zahl) Ordnung der zu verwendenden Finite-Differenzen-Formel. Ungerade ganze Zahlen werden auf die nächste gerade ganze Zahl aufgerundet.

initial_stepFloat, Standard: 0.5

Die (absolute) anfängliche Schrittgröße für die Approximation der Finite-Differenzen-Ableitung.

step_factorFloat, Standard: 2.0

Der Faktor, um den die Schrittgröße in jeder Iteration *reduziert* wird; d. h. die Schrittgröße in Iteration 1 ist initial_step/step_factor. Wenn step_factor < 1, sind nachfolgende Schritte größer als der anfängliche Schritt; dies kann nützlich sein, wenn Schritte, die kleiner als ein bestimmter Schwellenwert sind, unerwünscht sind (z. B. aufgrund von subtraktiven Fehler).

maxiterInteger, Standard: 10

Die maximale Anzahl von Iterationen, die der Algorithmus durchführen soll. Siehe Hinweise.

Rückgabe:

res_RichResult

Ein Objekt, das einer Instanz von scipy.optimize.OptimizeResult ähnelt, mit den folgenden Attributen. Die Beschreibungen sind so formuliert, als wären die Werte Skalare; wenn f jedoch ein Array zurückgibt, sind die Ausgaben Arrays derselben Form.

successBool-Array

True, wenn der Algorithmus erfolgreich beendet wurde (Status 0); andernfalls False.

statusInteger-Array

Eine Ganzzahl, die den Exit-Status des Algorithmus darstellt.

0 : Der Algorithmus konvergierte gegen die angegebenen Toleranzen.
-1 : Die Fehlerschätzung stieg an, daher wurde die Iteration beendet.
-2 : Die maximale Anzahl von Iterationen wurde erreicht.
-3 : Ein nicht-endlicher Wert wurde angetroffen.

ddfFloat-Array

Die Hesse-Matrix von f an der Stelle x, wenn der Algorithmus erfolgreich beendet wurde.

errorFloat-Array

Eine Schätzung des Fehlers: die Größe der Differenz zwischen der aktuellen Schätzung der Hesse-Matrix und der Schätzung in der vorherigen Iteration.

nfevInteger-Array

Die Anzahl der Punkte, an denen f ausgewertet wurde.

Jedes Element eines Attributs ist mit dem entsprechenden Element von ddf verbunden. Zum Beispiel ist das Element [i, j] von nfev die Anzahl der Punkte, an denen f zur Berechnung des Elements [i, j] von ddf ausgewertet wurde.

Siehe auch

derivative, jacobian

Hinweise

Angenommen, wir möchten die Hesse-Matrix einer Funktion \(f: \mathbf{R}^m \rightarrow \mathbf{R}\) auswerten und weisen der Variablen m den positiven ganzzahligen Wert von \(m\) zu. Wenn wir die Hesse-Matrix an einem einzelnen Punkt auswerten möchten, dann

Muss das Argument x ein Array der Form (m,) sein
Das Argument f muss vektorisiert sein, um ein Array der Form (m, ...) zu akzeptieren. Die erste Achse repräsentiert die \(m\) Eingaben von \(f\); die verbleibenden Achsen, die durch Ellipsen angezeigt werden, dienen zur Auswertung der Funktion an mehreren Abszissen in einem einzigen Aufruf.
Das Argument f muss ein Array der Form (...) zurückgeben.
Das Attribut dff des Ergebnisobjekts ist ein Array der Form (m, m), die Hesse-Matrix.

Diese Funktion ist auch in dem Sinne vektorisiert, dass die Hesse-Matrix an k Punkten in einem einzigen Aufruf ausgewertet werden kann. In diesem Fall wäre x ein Array der Form (m, k), f würde ein Array der Form (m, ...) akzeptieren und ein Array der Form (...) zurückgeben, und das Attribut ddf des Ergebnisses hätte die Form (m, m, k). Beachten Sie, dass die Achse, die mit den k Punkten verbunden ist, innerhalb der durch (...) angedeuteten Achsen enthalten ist.

Derzeit wird hessian durch verschachtelte Aufrufe von jacobian implementiert. Alle an hessian übergebenen Optionen werden für beide inneren und äußeren Aufrufe verwendet, mit einer Ausnahme: die in den inneren jacobian-Aufrufen verwendete rtol wird um einen Faktor von 100 verkleinert, mit der Erwartung, dass der innere Fehler ignoriert werden kann. Eine Folge davon ist, dass rtol nicht kleiner als das 100-fache der Präzision des Datentyps von x gesetzt werden sollte; andernfalls wird eine Warnung ausgegeben.

Referenzen

[1]

Hesse-Matrix, *Wikipedia*, https://en.wikipedia.org/wiki/Hessian_matrix

Beispiele

Die Rosenbrock-Funktion bildet von \(\mathbf{R}^m \rightarrow \mathbf{R}\) ab; die SciPy-Implementierung scipy.optimize.rosen ist vektorisiert, um ein Array der Form (m, ...) zu akzeptieren und ein Array der Form ... zurückzugeben. Angenommen, wir möchten die Hesse-Matrix an der Stelle [0.5, 0.5, 0.5] auswerten.

>>> import numpy as np
>>> from scipy.differentiate import hessian
>>> from scipy.optimize import rosen, rosen_hess
>>> m = 3
>>> x = np.full(m, 0.5)
>>> res = hessian(rosen, x)
>>> ref = rosen_hess(x)  # reference value of the Hessian
>>> np.allclose(res.ddf, ref)
True

hessian ist vektorisiert, um die Hesse-Matrix an mehreren Punkten in einem einzigen Aufruf auszuwerten.

>>> rng = np.random.default_rng()
>>> x = rng.random((m, 10))
>>> res = hessian(rosen, x)
>>> ref = [rosen_hess(xi) for xi in x.T]
>>> ref = np.moveaxis(ref, 0, -1)
>>> np.allclose(res.ddf, ref)
True