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)[原始碼]#

括號單變數實值函數的最小值。

對於 f 輸出的每個元素，bracket_minimum 尋找純量括號點 xl < xm < xr 使得 fl >= fm <= fr，其中一個不等式是嚴格的。

如果函數是強單峰的，則保證此函數會找到有效的括號，但在其他條件下也可能找到括號。

當 xm0、xl0、xr0、xmin、xmax、factor 和 args 的元素是（可相互廣播的）陣列時，此函數以元素方式運作。

參數:

f可呼叫物件

要括號求根的函數。簽名必須是

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

其中 x 的每個元素都是有限實數，而 args 是一個元組，其中可能包含任意數量的可與 x 廣播的陣列。

f 必須是一個元素級函數：對於所有索引 i，每個元素 f(x)[i] 必須等於 f(x[i])。它不得改變陣列 x 或 args 中的陣列。

xm0: float array_like

括號中點的起始猜測值。

xl0, xr0: float array_like, optional

括號左端點和右端點的起始猜測值。必須可與所有其他陣列輸入廣播。

xmin, xmaxfloat array_like, optional

括號的最小和最大允許端點，包含在內。必須可與所有其他陣列輸入廣播。

factorfloat array_like, default: 2

用於擴大括號的因子。請參閱注意事項。

argstuple of array_like, optional

要傳遞給 f 的額外位置陣列引數。如果想要求根的可呼叫物件需要不可與 x 廣播的引數，請使用 f 包裝該可呼叫物件，以便 f 僅接受 x 和可廣播的 *args。

maxiterint, default: 1000

要執行的演算法最大迭代次數。

返回:

res_RichResult

一個類似於 scipy.optimize.OptimizeResult 實例的物件，具有以下屬性。描述的寫法如同值將為純量；但是，如果 f 返回陣列，則輸出將是相同形狀的陣列。

successbool 陣列

演算法成功終止時為 True（狀態為 0）；否則為 False。

statusint 陣列

一個表示演算法退出狀態的整數。

0 : 演算法產生有效的括號。
-1 : 括號擴展到允許的極限。假設單峰性，這表示極限處的端點是最小值。
-2 : 已達到最大迭代次數。
-3 : 遇到非有限值。
-4 : None 不應通過。
-5 : 初始括號不滿足 xmin <= xl0 < xm0 < xr0 <= xmax。

bracketfloat 陣列的 3 元組

如果演算法成功終止，則為括號的左、中和右點。

f_bracketfloat 陣列的 3 元組

括號的左、中和右點的函數值。

nfevint 陣列

為了找到根，f 被評估的橫座標數量。這與 f 被呼叫的次數不同，因為函數可能在單次呼叫中在多個點進行評估。

nitint 陣列

已執行的演算法迭代次數。

另請參閱

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

注意事項

與 scipy.optimize.bracket 類似，此函數旨在尋找實點 xl < xm < xr 使得 f(xl) >= f(xm) 且 f(xr) >= f(xm)，其中至少一個不等式是嚴格的。與 scipy.optimize.bracket 不同，此函數可以在陣列輸入上以向量化方式運作，只要輸入陣列彼此可廣播即可。同樣與 scipy.optimize.bracket 不同，使用者可以為所需的括號指定最小和最大端點。

給定初始三點 xl = xl0、xm = xm0、xr = xr0，演算法檢查這些點是否已給出有效的括號。如果沒有，則在「下坡」方向選擇一個新的端點 w，xm 成為新的相反端點，並且 xl 或 xr 成為新的中點，具體取決於哪個方向是下坡。演算法從這裡重複。

新的端點 w 的選擇方式不同，取決於在下坡方向是否設定了邊界 xmin 或 xmax。不失一般性，假設下坡方向是向右，因此 f(xl) > f(xm) > f(xr)。如果右側沒有邊界，則 w 被選擇為 xr + factor * (xr - xm)，其中 factor 由使用者控制（預設為 2.0），以便步長以幾何比例增加。如果存在邊界，在本例中為 xmax，則 w 被選擇為 xmax - (xmax - xr)/factor，步長減慢到在 xmax 處停止。這種謹慎的方法確保不會錯過靠近但不同於邊界的最小值，同時也檢測在有限步數後達到 xmax 時，xmax 是否為最小值。

範例

假設我們希望最小化以下函數。

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

首先，我們必須找到一個有效的括號。該函數是單峰的，因此 bracket_minium 將很容易找到一個括號。

>>> 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)

實際上，括號點是有序的，並且中間括號點的函數值小於周圍點的函數值。

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

一旦我們有一個有效的括號，find_minimum 可以用於提供最小值的估計值。

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

bracket_minimum 和 find_minimum 接受大多數引數的陣列。例如，要一次找到參數 c 的幾個值的最小值和最小值

>>> 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.])