scipy.optimize.

approx_fprime#

scipy.optimize.approx_fprime(xk, f, epsilon=np.float64(1.4901161193847656e-08), *args)[Quelle]#

Endliche Differenzen-Approximation der Ableitungen einer skalar- oder vektorwertigen Funktion.

Wenn eine Funktion von \(R^n\) nach \(R^m\) abbildet, bilden ihre Ableitungen eine m-mal-n-Matrix namens Jacobi-Matrix, wobei ein Element \((i, j)\) die partielle Ableitung von f[i] nach xk[j] ist.

Parameter:

xkarray_like

Der Koordinatenvektor, an dem der Gradient von f bestimmt werden soll.

faufrufbar

Funktion, deren Ableitungen geschätzt werden sollen. Hat die Signatur f(xk, *args), wobei xk das Argument in Form eines 1-D-Arrays ist und args ein Tupel aus allen zusätzlichen festen Parametern ist, die zur vollständigen Spezifizierung der Funktion benötigt werden. Das an diese Funktion übergebene Argument xk ist ein ndarray der Form (n,) (niemals ein Skalar, auch wenn n=1). Es muss ein 1-D-array_like der Form (m,) oder ein Skalar zurückgeben.

Angenommen, der aufrufbare hat die Signatur f0(x, *my_args, **my_kwargs), wobei my_args und my_kwargs erforderliche Positions- und Schlüsselwortargumente sind. Anstatt f0 als aufrufbare zu übergeben, wickeln Sie sie so ein, dass nur x akzeptiert wird; z. B. übergeben Sie fun=lambda x: f0(x, *my_args, **my_kwargs) als aufrufbare, wobei my_args (Tupel) und my_kwargs (Dict) vor dem Aufruf dieser Funktion gesammelt wurden.

Geändert in Version 1.9.0: f kann jetzt ein 1-D-array_like zurückgeben, wobei die Jacobi-Matrix \((m, n)\) geschätzt wird.

epsilon{float, array_like}, optional

Inkrement zu xk, das zur Bestimmung des Funktionsgradienten verwendet wird. Wenn ein Skalar, werden dieselben Endlich-Differenzen-Deltas für alle partiellen Ableitungen verwendet. Wenn ein Array, sollte es einen Wert pro Element von xk enthalten. Standardmäßig sqrt(np.finfo(float).eps), was ungefähr 1,49e-08 entspricht.

*argsargs, optional

Alle anderen Argumente, die an f übergeben werden sollen.

Rückgabe:

jacndarray: Die partiellen Ableitungen von f nach xk.

Siehe auch

check_grad: Überprüft die Korrektheit der Gradientenfunktion anhand von approx_fprime.

Hinweise

Der Funktionsgradient wird durch die Vorwärts-Endlich-Differenzen-Formel bestimmt

         f(xk[i] + epsilon[i]) - f(xk[i])
f'[i] = ---------------------------------
                    epsilon[i]

Beispiele

>>> import numpy as np
>>> from scipy import optimize
>>> def func(x, c0, c1):
...     "Coordinate vector `x` should be an array of size two."
...     return c0 * x[0]**2 + c1*x[1]**2

>>> x = np.ones(2)
>>> c0, c1 = (1, 200)
>>> eps = np.sqrt(np.finfo(float).eps)
>>> optimize.approx_fprime(x, func, [eps, np.sqrt(200) * eps], c0, c1)
array([   2.        ,  400.00004208])