scipy.optimize.elementwise.

bracket_minimum#

scipy.optimize.elementwise.bracket_minimum(f, xm0, *, xl0=None, xr0=None, xmin=None, xmax=None, factor=None, args=(), maxiter=1000)[Quelle]#

Klammert das Minimum einer unimodalen, reellwertigen Funktion einer reellen Variablen.

Für jedes Element der Ausgabe von f sucht bracket_minimum die skalaren Klammerpunkte xl < xm < xr, sodass fl >= fm <= fr gilt, wobei eine der Ungleichungen strikt ist.

Die Funktion garantiert, eine gültige Klammer zu finden, wenn die Funktion stark unimodal ist, kann aber auch unter anderen Bedingungen eine Klammer finden.

Diese Funktion arbeitet elementweise, wenn xm0, xl0, xr0, xmin, xmax, factor und die Elemente von args (wechselseitig broadcastbare) Arrays sind.

Parameter:

faufrufbar

Die Funktion, für die die Wurzel geklammert werden soll. Die Signatur muss lauten:

f(x: array, *args) -> array

wobei jedes Element von x eine endliche reelle Zahl ist und args ein Tupel ist, das eine beliebige Anzahl von Arrays enthalten kann, die mit x broadcastfähig sind.

f muss eine elementweise Funktion sein: jedes Element f(x)[i] muss für alle Indizes i gleich f(x[i]) sein. Sie darf das Array x oder die Arrays in args nicht verändern.

xm0: float array_like

Startschätzung für den mittleren Punkt der Klammer.

xl0, xr0: float array_like, optional

Startschätzungen für linke und rechte Endpunkte der Klammer. Müssen mit allen anderen Array-Eingaben broadcastbar sein.

xmin, xmaxfloat array_like, optional

Minimale und maximale zulässige Endpunkte der Klammer, einschließlich. Müssen mit allen anderen Array-Eingaben broadcastbar sein.

factorfloat array_like, Standardwert: 2

Der Faktor, der zum Erweitern der Klammer verwendet wird. Siehe Hinweise.

argstuple of array_like, optional

Zusätzliche positionelle Array-Argumente, die an f übergeben werden. Wenn die aufgerufene Funktion, für die die Wurzel gewünscht wird, Argumente benötigt, die nicht mit x broadcastbar sind, wickeln Sie diese aufgerufene Funktion mit f so, dass f nur x und broadcastbare *args akzeptiert.

maxiterint, Standardwert: 1000

Die maximale Anzahl der Algorithmusiterationen, die durchgeführt werden sollen.

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 hat eine gültige Klammer erzeugt.
-1 : Die Klammer erweiterte sich bis zu den zulässigen Grenzen. Unter der Annahme von Unimodalität impliziert dies, dass der Endpunkt an der Grenze ein Minimierer ist.
-2 : Die maximale Anzahl von Iterationen wurde erreicht.
-3 : Ein nicht-endlicher Wert wurde angetroffen.
-4 : None soll bestehen.
-5 : Die anfängliche Klammer erfüllt nicht xmin <= xl0 < xm0 < xr0 <= xmax.

bracket3-Tupel aus Float-Arrays

Die linken, mittleren und rechten Punkte der Klammer, wenn der Algorithmus erfolgreich terminiert ist.

f_bracket3-Tupel aus Float-Arrays

Der Funktionswert an den linken, mittleren und rechten Punkten der Klammer.

nfevInteger-Array

Die Anzahl der Abszissen, an denen f zur Bestimmung der Wurzel ausgewertet wurde. Dies unterscheidet sich von der Anzahl der Male, die f *aufgerufen* wird, da die Funktion in einem einzigen Aufruf an mehreren Punkten ausgewertet werden kann.

nitint array

Die Anzahl der Iterationen des Algorithmus, die durchgeführt wurden.

Siehe auch

scipy.optimize.bracket
scipy.optimize.elementwise.find_minimum

Hinweise

Ähnlich wie scipy.optimize.bracket sucht diese Funktion nach reellen Punkten xl < xm < xr, so dass f(xl) >= f(xm) und f(xr) >= f(xm) gilt, wobei mindestens eine der Ungleichungen strikt ist. Im Gegensatz zu scipy.optimize.bracket kann diese Funktion vektorisiert auf Array-Eingaben angewendet werden, solange die Eingabe-Arrays untereinander broadcastbar sind. Anders als scipy.optimize.bracket können Benutzer auch minimale und maximale Endpunkte für die gewünschte Klammer angeben.

Gegeben ein anfängliches Trio von Punkten xl = xl0, xm = xm0, xr = xr0, prüft der Algorithmus, ob diese Punkte bereits eine gültige Klammer ergeben. Wenn nicht, wird ein neuer Endpunkt w in der "absteigenden" Richtung gewählt, xm wird zum neuen gegenüberliegenden Endpunkt und entweder xl oder xr wird zum neuen Mittelpunkt, je nachdem, in welche Richtung es abwärts geht. Der Algorithmus wiederholt dies.

Der neue Endpunkt w wird unterschiedlich gewählt, je nachdem, ob eine Grenze xmin oder xmax in der absteigenden Richtung festgelegt wurde. Ohne Verlust der Allgemeinheit nehmen wir an, die absteigende Richtung ist nach rechts, so dass f(xl) > f(xm) > f(xr). Wenn keine Grenze nach rechts vorhanden ist, wird w als xr + factor * (xr - xm) gewählt, wobei factor vom Benutzer gesteuert wird (Standard ist 2,0), so dass sich die Schrittgrößen geometrisch proportionieren. Wenn eine Grenze vorhanden ist, in diesem Fall xmax, dann wird w als xmax - (xmax - xr)/factor gewählt, wobei sich die Schritte bei xmax verlangsamen. Dieser vorsichtige Ansatz stellt sicher, dass ein Minimum nahe, aber von der Grenze verschieden, nicht verpasst wird, und erkennt gleichzeitig, ob die Grenze xmax ein Minimierer ist, wenn xmax nach einer endlichen Anzahl von Schritten erreicht wird.

Beispiele

Nehmen wir an, wir wollen die folgende Funktion minimieren.

>>> def f(x, c=1):
...     return (x - c)**2 + 2

Zuerst müssen wir eine gültige Klammer finden. Die Funktion ist unimodal, daher findet bracket_minium leicht eine Klammer.

>>> from scipy.optimize import elementwise
>>> res_bracket = elementwise.bracket_minimum(f, 0)
>>> res_bracket.success
True
>>> res_bracket.bracket
(0.0, 0.5, 1.5)

Tatsächlich sind die Klammerpunkte geordnet und der Funktionswert am mittleren Klammerpunkt ist kleiner als an den umgebenden Punkten.

>>> xl, xm, xr = res_bracket.bracket
>>> fl, fm, fr = res_bracket.f_bracket
>>> (xl < xm < xr) and (fl > fm <= fr)
True

Sobald wir eine gültige Klammer haben, kann find_minimum verwendet werden, um einen Schätzer des Minimierers zu liefern.

>>> res_minimum = elementwise.find_minimum(f, res_bracket.bracket)
>>> res_minimum.x
1.0000000149011612

bracket_minimum und find_minimum akzeptieren Arrays für die meisten Argumente. Zum Beispiel, um die Minimierer und Minima für einige Werte des Parameters c gleichzeitig zu finden

>>> import numpy as np
>>> c = np.asarray([1, 1.5, 2])
>>> res_bracket = elementwise.bracket_minimum(f, 0, args=(c,))
>>> res_bracket.bracket
(array([0. , 0.5, 0.5]), array([0.5, 1.5, 1.5]), array([1.5, 2.5, 2.5]))
>>> res_minimum = elementwise.find_minimum(f, res_bracket.bracket, args=(c,))
>>> res_minimum.x
array([1.00000001, 1.5       , 2.        ])
>>> res_minimum.f_x
array([2., 2., 2.])