scipy.optimize.

brute#

scipy.optimize.brute(func, ranges, args=(), Ns=20, full_output=0, finish=<function fmin>, disp=False, workers=1)[Quelle]#

Minimiert eine Funktion über einen gegebenen Bereich mittels Brute-Force.

Verwendet die „Brute-Force“-Methode, d.h., berechnet den Funktionswert an jedem Punkt eines mehrdimensionalen Gitters von Punkten, um das globale Minimum der Funktion zu finden.

Die Funktion wird überall im Bereich mit dem Datentyp des ersten Funktionsaufrufs ausgewertet, wie er von der NumPy-Funktion vectorize erzwungen wird. Der Wert und Typ der Funktionsauswertung, die bei full_output=True zurückgegeben werden, werden zusätzlich durch das Argument finish beeinflusst (siehe Hinweise).

Der Brute-Force-Ansatz ist ineffizient, da die Anzahl der Gitterpunkte exponentiell ansteigt – die Anzahl der zu auswertenden Gitterpunkte ist Ns ** len(x). Folglich können selbst bei grober Gitterabstandsauflösung selbst mäßig große Probleme lange dauern und/oder zu Speicherbeschränkungen führen.

Parameter:

funccallable: Die zu minimierende Zielfunktion. Muss im Format f(x, *args) sein, wobei x das Argument in Form eines 1D-Arrays und args ein Tupel zusätzlicher fester Parameter ist, die zur vollständigen Spezifikation der Funktion erforderlich sind.
rangestuple: Jede Komponente des ranges Tupels muss entweder ein „Slice-Objekt“ oder ein Bereichstupel der Form (low, high) sein. Das Programm verwendet diese, um das Gitter von Punkten zu erstellen, auf denen die Zielfunktion berechnet wird. Siehe Hinweis 2 für weitere Details.
argstuple, optional: Zusätzliche feste Parameter, die zur vollständigen Spezifikation der Funktion erforderlich sind.
Nsint, optional: Anzahl der Gitterpunkte entlang der Achsen, falls nicht anders angegeben. Siehe Hinweis 2.
full_outputbool, optional: Wenn True, gib das Auswertungsraster und die Zielfunktionswerte darauf zurück.
finishcallable, optional: Eine Optimierungsfunktion, die mit dem Ergebnis der Brute-Force-Minimierung als Startwert aufgerufen wird. finish sollte func und den Startwert als Positionsargumente sowie args als Schlüsselwortargumente entgegennehmen. Es kann zusätzlich full_output und/oder disp als Schlüsselwortargumente annehmen. Verwenden Sie None, wenn keine „Polishing“-Funktion verwendet werden soll. Siehe Hinweise für weitere Details.
dispbool, optional: Auf True gesetzt, um Konvergenzmeldungen vom finish Callable auszugeben.
workersint oder Map-ähnliches aufrufbare Objekt, optional: Wenn workers ein int ist, wird das Gitter in workers Abschnitte unterteilt und parallel ausgewertet (verwendet multiprocessing.Pool). Geben Sie -1 an, um alle verfügbaren Kerne des Prozesses zu nutzen. Alternativ können Sie ein map-ähnliches Callable übergeben, z.B. multiprocessing.Pool.map, um das Gitter parallel auszuwerten. Diese Auswertung erfolgt als workers(func, iterable). Erfordert, dass func pickelbar ist.

Hinzugefügt in Version 1.3.0.

Rückgabe:

x0ndarray: Ein 1D-Array mit den Koordinaten eines Punkts, an dem die Zielfunktion ihren Minimalwert hatte. (Siehe Hinweis 1, welcher Punkt zurückgegeben wird.)
fvalfloat: Funktionswert am Punkt x0. (Zurückgegeben, wenn full_output True ist.)
gridtuple: Darstellung des Auswertungsrasters. Es hat die gleiche Länge wie x0. (Zurückgegeben, wenn full_output True ist.)
Joutndarray: Funktionswerte an jedem Punkt des Auswertungsrasters, d.h. Jout = func(*grid). (Zurückgegeben, wenn full_output True ist.)

Siehe auch

basinhopping, differential_evolution

Hinweise

Hinweis 1: Das Programm findet den Gitterpunkt, an dem der niedrigste Wert der Zielfunktion auftritt. Wenn finish None ist, ist das der zurückgegebene Punkt. Wenn das globale Minimum innerhalb (oder nicht sehr weit außerhalb) der Gittergrenzen auftritt und das Gitter fein genug ist, wird dieser Punkt in der Nähe des globalen Minimums liegen.

Benutzer verwenden oft ein anderes Optimierungsprogramm, um die Gitterpunktwerte zu „polieren“, d.h. um ein präziseres (lokales) Minimum in der Nähe des besten Gitterpunkts von brute zu suchen. Die Option finish der Funktion brute bietet eine bequeme Möglichkeit dafür. Jedes verwendete Polishing-Programm muss die Ausgabe von brute als Startwert als Positionsargument entgegennehmen und die Eingabewerte von brute für args als Schlüsselwortargumente entgegennehmen, andernfalls wird ein Fehler ausgelöst. Es kann zusätzlich full_output und/oder disp als Schlüsselwortargumente annehmen.

brute geht davon aus, dass die Funktion finish entweder ein OptimizeResult-Objekt oder ein Tupel der Form zurückgibt: (xmin, Jmin, ... , statuscode), wobei xmin der minimierende Wert des Arguments ist, Jmin der Minimalwert der Zielfunktion ist, „…“ können andere zurückgegebene Werte sein (die von brute nicht verwendet werden) und statuscode ist der Statuscode des finish Programms.

Beachten Sie, dass, wenn finish nicht None ist, die zurückgegebenen Werte die der finish Funktion sind, *nicht* die Gitterpunktwerte. Folglich werden die Ergebnisse des finish Programms normalerweise nicht mit einem Gitterpunkt übereinstimmen und können außerhalb der Gittergrenzen liegen, obwohl brute seine Suche auf die eingegebenen Gitterpunkte beschränkt. Wenn also nur ein Minimum über die bereitgestellten Gitterpunkte gefunden werden muss, stellen Sie sicher, dass finish=None übergeben wird.

Hinweis 2: Das Gitter von Punkten ist ein numpy.mgrid Objekt. Für brute haben die Eingaben ranges und Ns die folgende Auswirkung. Jede Komponente des ranges Tupels kann entweder ein Slice-Objekt oder ein Zweier-Tupel sein, das einen Wertebereich angibt, z.B. (0, 5). Wenn die Komponente ein Slice-Objekt ist, verwendet brute es direkt. Wenn die Komponente ein Zweier-Tupel-Bereich ist, konvertiert brute es intern in ein Slice-Objekt, das Ns Punkte von seinem niedrigeren zum höheren Wert interpoliert, einschließlich beider.

Beispiele

Wir illustrieren die Verwendung von brute, um das globale Minimum einer Funktion von zwei Variablen zu suchen, die als Summe einer positiv-definiten quadratischen Funktion und zweier tiefer „Gauß-förmiger“ Krater gegeben ist. Speziell definieren wir die Zielfunktion f als die Summe von drei anderen Funktionen, f = f1 + f2 + f3. Wir nehmen an, dass jede dieser Funktionen eine Signatur (z, *params) hat, wobei z = (x, y) und params sowie die Funktionen wie unten definiert sind.

>>> import numpy as np
>>> params = (2, 3, 7, 8, 9, 10, 44, -1, 2, 26, 1, -2, 0.5)
>>> def f1(z, *params):
...     x, y = z
...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params
...     return (a * x**2 + b * x * y + c * y**2 + d*x + e*y + f)

>>> def f2(z, *params):
...     x, y = z
...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params
...     return (-g*np.exp(-((x-h)**2 + (y-i)**2) / scale))

>>> def f3(z, *params):
...     x, y = z
...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params
...     return (-j*np.exp(-((x-k)**2 + (y-l)**2) / scale))

>>> def f(z, *params):
...     return f1(z, *params) + f2(z, *params) + f3(z, *params)

Somit kann die Zielfunktion lokale Minima in der Nähe des Minimums jeder der drei Funktionen haben, aus denen sie sich zusammensetzt. Um fmin zu verwenden, um ihr Gitterpunkt-Ergebnis zu polieren, können wir dann wie folgt fortfahren:

>>> rranges = (slice(-4, 4, 0.25), slice(-4, 4, 0.25))
>>> from scipy import optimize
>>> resbrute = optimize.brute(f, rranges, args=params, full_output=True,
...                           finish=optimize.fmin)
>>> resbrute[0]  # global minimum
array([-1.05665192,  1.80834843])
>>> resbrute[1]  # function value at global minimum
-3.4085818767

Beachten Sie, dass, wenn finish auf None gesetzt worden wäre, wir den Gitterpunkt [-1.0 1.75] erhalten hätten, an dem der gerundete Funktionswert -2,892 beträgt.