scipy.optimize.

basinhopping

scipy.optimize.basinhopping(func, x0, niter=100, T=1.0, stepsize=0.5, minimizer_kwargs=None, take_step=None, accept_test=None, callback=None, interval=50, disp=False, niter_success=None, seed=None, *, target_accept_rate=0.5, stepwise_factor=0.9)

使用 basin-hopping 算法找到函数的全局最小值。

Basin-hopping 是一种两阶段方法，它将全局步进算法与每一步的局部最小化相结合。旨在模拟原子簇能量最小化的自然过程，它适用于具有“漏斗状但崎岖”能量景观的类似问题 [5].

由于步进、步进接受和最小化方法都是可定制的，因此此函数也可以用于实现其他两阶段方法。

参数：

funccallable f(x, *args)

要优化的函数。 args 可以作为字典 minimizer_kwargs 中的可选项传递

x0array_like

初始猜测。

niterinteger, optional

basin-hopping 迭代次数。将总共运行 niter + 1 次局部最小化器。

Tfloat, optional

接受或拒绝标准的“温度”参数。较高的“温度”意味着将接受函数值更大的跳跃。为了获得最佳结果，T 应该与局部最小值之间的分离（在函数值中）相当。

stepsizefloat, optional

用于随机位移的最大步长。

minimizer_kwargsdict, optional

要传递给局部最小化器 scipy.optimize.minimize 的额外关键字参数。一些重要的选项可能是

methodstr

最小化方法（例如 "L-BFGS-B"）

argstuple

传递给目标函数 (func) 及其导数（雅可比矩阵、海森矩阵）的额外参数。

take_stepcallable take_step(x), optional

用此例程替换默认的步进例程。默认的步进例程是坐标的随机位移，但对于某些系统，其他步进算法可能更好。 take_step 可以选择具有属性 take_step.stepsize。如果此属性存在，则 basinhopping 将调整 take_step.stepsize 以便尝试优化全局最小值搜索。

accept_testcallable, accept_test(f_new=f_new, x_new=x_new, f_old=fold, x_old=x_old), optional

定义一个测试，该测试将用于判断是否接受该步。这将与基于“温度” T 的 Metropolis 测试一起使用。可接受的返回值为 True、False 或 "force accept"。如果任何测试返回 False，则拒绝该步。如果是后者，则这将覆盖任何其他测试以接受该步。这可以用来强制退出 basinhopping 所困的局部最小值。

callbackcallable, callback(x, f, accept), optional

一个回调函数，它将针对找到的所有最小值调用。 x 和 f 是试验最小值的坐标和函数值，而 accept 表示该最小值是否被接受。例如，这可以用来保存找到的最低 N 个最小值。此外，callback 可用于通过可选地返回 True 来指定用户定义的停止条件以停止 basinhopping 例程。

intervalinteger, optional

更新 stepsize 的频率间隔

dispbool, optional

设置为 True 以打印状态消息

niter_successinteger, optional

如果全局最小值候选在这些迭代次数内保持不变，则停止运行。

seed{None, int, numpy.random.Generator, numpy.random.RandomState}, optional

如果 seed 为 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并使用 seed 进行播种。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。指定 seed 以进行可重复的最小化。使用此种子生成的随机数只会影响默认的 Metropolis accept_test 和默认的 take_step。如果您提供自己的 take_step 和 accept_test，并且这些函数使用随机数生成，那么这些函数负责其随机数生成器的状态。

target_accept_ratefloat, optional

用于调整 stepsize 的目标接受率。如果当前接受率大于目标，则 stepsize 会增加。否则，它将减少。范围为 (0, 1)。默认为 0.5。

在版本 1.8.0 中添加。

stepwise_factorfloat, optional

每次更新时，stepsize 将乘以或除以此逐步因子。范围为 (0, 1)。默认为 0.9。

在版本 1.8.0 中添加。

返回值：

resOptimizeResult

优化结果表示为 OptimizeResult 对象。重要的属性是： x 是解数组，fun 是解处的函数值，而 message 描述了终止的原因。在最低最小值处由所选最小化器返回的 OptimizeResult 对象也包含在此对象中，可以通过 lowest_optimization_result 属性访问。有关其他属性的说明，请参见 OptimizeResult。

另请参阅

minimize

每一步 basin-hopping 调用一次的局部最小化函数。 minimizer_kwargs 将传递给此例程。

备注

盆地跳跃是一种随机算法，它试图找到一个或多个变量的平滑标量函数的全局最小值 [1] [2] [3] [4]。该算法的当前形式由 David Wales 和 Jonathan Doye 描述 [2] http://www-wales.ch.cam.ac.uk/。

该算法是迭代的，每个循环由以下特征组成

1. 坐标的随机扰动

2. 局部最小化

3. 根据最小化函数值接受或拒绝新坐标

这里使用的接受测试是标准蒙特卡罗算法的 Metropolis 准则，尽管还有许多其他可能性 [3]。

这种全局最小化方法已被证明对物理和化学中的各种问题极其有效。当函数具有许多由大型障碍物隔开的最小值时，它特别有用。参见 剑桥集群数据库，了解主要使用盆地跳跃优化的分子系统数据库。该数据库包括超过 300 个自由度的最小化问题。

参见免费软件程序 GMIN，了解盆地跳跃的 Fortran 实现。该实现具有上述过程的许多变体，包括更先进的步进算法和备选接受准则。

对于随机全局优化，无法确定是否已实际找到真正的全局最小值。相反，作为一致性检查，可以从多个不同的随机起点运行该算法，以确保每个示例中找到的最低最小值已收敛到全局最小值。出于这个原因，basinhopping 默认情况下只运行 niter 次迭代并返回找到的最低最小值。最终用户需要确保这实际上是全局最小值。

选择 stepsize：这是 basinhopping 中的一个关键参数，取决于要解决的问题。步长在每个维度上从 x0-stepsize 到 x0+stepsize 的区域内均匀选择。理想情况下，它应该与正在优化的函数的局部最小值之间的典型分离（在参数值中）相当。 basinhopping 默认情况下会调整 stepsize 以找到最佳值，但这可能需要许多迭代。如果你为 stepsize 设置一个合理的初始值，你会得到更快的结果。

选择 T：参数 T 是 Metropolis 准则中使用的“温度”。如果 func(xnew) < func(xold)，则始终接受盆地跳跃步骤。否则，它们将以概率被接受

exp( -(func(xnew) - func(xold)) / T )

因此，为了获得最佳结果，T 应该与局部最小值之间的典型差异（在函数值中）相当。（局部最小值之间“墙”的高度无关紧要。）

如果 T 为 0，则该算法变为单调盆地跳跃，其中所有增加能量的步骤都会被拒绝。

在版本 0.12.0 中添加。

参考文献

[1]

Wales, David J. 2003, 能量景观，剑桥大学出版社，剑桥，英国。

[2] (1,2)

Wales, D J，和 Doye J P K，通过盆地跳跃进行全局优化以及包含多达 110 个原子的 Lennard-Jones 簇的最低能量结构。物理化学杂志 A，1997，101，5111。

[3] (1,2)

Li，Z. 和 Scheraga，H. A.，蒙特卡罗最小化方法解决蛋白质折叠中的多最小值问题，美国国家科学院院刊，1987，84，6611。

[4]

Wales，D. J. 和 Scheraga，H. A.，簇、晶体和生物大分子的全局优化，科学，1999，285，1368。

[5]

Olson，B.，Hashmi，I.，Molloy，K. 和 Shehu1，A.，盆地跳跃作为生物大分子表征的通用且通用的优化框架，人工智能进展，2012 年卷（2012 年），文章 ID 674832，DOI:10.1155/2012/674832

示例

在你的浏览器中试试！

以下示例是一个一维最小化问题，在抛物线上叠加了许多局部最小值。

>>> import numpy as np
>>> from scipy.optimize import basinhopping
>>> func = lambda x: np.cos(14.5 * x - 0.3) + (x + 0.2) * x
>>> x0 = [1.]

盆地跳跃在内部使用局部最小化算法。我们将使用参数 minimizer_kwargs 来告诉盆地跳跃使用哪个算法以及如何设置该最小化器。此参数将传递给 scipy.optimize.minimize。

>>> minimizer_kwargs = {"method": "BFGS"}
>>> ret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs,
...                    niter=200)
>>> # the global minimum is:
>>> ret.x, ret.fun
-0.1951, -1.0009

接下来考虑一个二维最小化问题。此外，这次我们将使用梯度信息来显著加速搜索。

>>> def func2d(x):
...     f = np.cos(14.5 * x[0] - 0.3) + (x[1] + 0.2) * x[1] + (x[0] +
...                                                            0.2) * x[0]
...     df = np.zeros(2)
...     df[0] = -14.5 * np.sin(14.5 * x[0] - 0.3) + 2. * x[0] + 0.2
...     df[1] = 2. * x[1] + 0.2
...     return f, df

我们还将使用不同的局部最小化算法。此外，我们必须告诉最小化器我们的函数返回能量和梯度（雅可比行列式）。

>>> minimizer_kwargs = {"method":"L-BFGS-B", "jac":True}
>>> x0 = [1.0, 1.0]
>>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,
...                    niter=200)
>>> print("global minimum: x = [%.4f, %.4f], f(x) = %.4f" % (ret.x[0],
...                                                           ret.x[1],
...                                                           ret.fun))
global minimum: x = [-0.1951, -0.1000], f(x) = -1.0109

这是一个使用自定义步进例程的示例。假设你想让第一个坐标比其他坐标采取更大的步骤。可以这样实现

>>> class MyTakeStep:
...    def __init__(self, stepsize=0.5):
...        self.stepsize = stepsize
...        self.rng = np.random.default_rng()
...    def __call__(self, x):
...        s = self.stepsize
...        x[0] += self.rng.uniform(-2.*s, 2.*s)
...        x[1:] += self.rng.uniform(-s, s, x[1:].shape)
...        return x

由于 MyTakeStep.stepsize 存在，因此盆地跳跃将调整 stepsize 的大小以优化搜索。我们将使用与之前相同的二维函数

>>> mytakestep = MyTakeStep()
>>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,
...                    niter=200, take_step=mytakestep)
>>> print("global minimum: x = [%.4f, %.4f], f(x) = %.4f" % (ret.x[0],
...                                                           ret.x[1],
...                                                           ret.fun))
global minimum: x = [-0.1951, -0.1000], f(x) = -1.0109

现在，让我们做一个使用自定义回调函数的示例，该函数打印找到的每个最小值的值

>>> def print_fun(x, f, accepted):
...         print("at minimum %.4f accepted %d" % (f, int(accepted)))

这次我们将只运行 10 个盆地跳跃步骤。

>>> rng = np.random.default_rng()
>>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,
...                    niter=10, callback=print_fun, seed=rng)
at minimum 0.4159 accepted 1
at minimum -0.4317 accepted 1
at minimum -1.0109 accepted 1
at minimum -0.9073 accepted 1
at minimum -0.4317 accepted 0
at minimum -0.1021 accepted 1
at minimum -0.7425 accepted 1
at minimum -0.9073 accepted 1
at minimum -0.4317 accepted 0
at minimum -0.7425 accepted 1
at minimum -0.9073 accepted 1

在 -1.0109 处的最小值实际上是全局最小值，已经在第 8 次迭代中找到。

返回在新标签页中打开