Python 在最大运行时间后停止scipy.optimize.minimize

我在集群上运行

scipy.optimize.minimize（方法='L-BFGS-B'）

。运行超过72小时的任务将被终止，而不保存结果。在T=48小时的运行时间过后，是否有办法退出scipy.optimize.minimize（）

一种方法是估计一次迭代的计算时间，然后在

options

参数中相应地设置

maxiter

另一种方法是定义一个类，该类修改函数

fun

，使其在指定时间后返回错误，并记录最后一个输入值

x

及其输出

fun（x）

：

这样，可以在调用

fun

后停止优化，例如，在第一次调用后2秒之后：

## Objective function:
def fun(x):
    time.sleep(5)
    return sum(x**2)

## Minimize with early stopping:
fun_timed = TimedFun(fun=fun, stop_after=2)
try:
    minimize(fun=fun_timed.fun, x0=np.array([100]), method='L-BFGS-B')
except Exception as e:
    print("Error: " + str(e))
# Error: Time is over.

## Retrieve last evaluated `x` and `fun(x)`:
print('x=', fun_timed.x, ', fun(x)=', fun_timed.fun_value, sep='')
# x=[100.], fun(x)=10000.0

顺便说一句，请查看我的软件包，它允许您通过并行计算加速优化，并返回每个步骤的评估值

x

、

fun（x）

、和

jac（x）

from optimparallel import minimize_parallel
minimize_parallel(fun=fun, x0=np.array([100]), parallel={'loginfo': True})
#      fun: 2.565413976271745e-17
# hess_inv: array([[0.50000039]])
#      jac: array([-1.29983171e-10])
#  loginfo: {'x': array([[ 1.00000000e+02],
#       [ 9.90000000e+01],
#       [ 9.50000000e+01],
#       [ 7.90000000e+01],
#       [ 8.22875951e-05],
#       [-5.06499159e-09]]), 'fun': array([[1.00000000e+04],
#       [9.80100000e+03],
#       [9.02500000e+03],
#       [6.24100000e+03],
#       [6.77124832e-09],
#       [2.56541398e-17]]), 'jac': array([[ 1.99999886e+02],
#       [ 1.97999907e+02],
#       [ 1.89999810e+02],
#       [ 1.57999875e+02],
#       [ 1.64585190e-04],
#       [-1.29983171e-10]])}
#  message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'
#     nfev: 6
#      nit: 3
#   status: 0
#  success: True
#        x: array([-5.06499159e-09])

来自optimparallel import的

最小化\u parallel
最小化并行（fun=fun，x0=np.array（[100]），并行={'loginfo'：True}）
#乐趣：2.565413976271745e-17
#hess_库存：数组（[[0.50000039]]
#jac:数组（[-1.29983171e-10]）
#loginfo:{'x'：数组（[[1.00000000e+02]，
#[9.90000000e+01]，
#[9.50000000e+01]，
#[7.90000000e+01]，
#[8.22875951e-05]，
#[-5.06499159e-09]]，“乐趣”：数组（[[1.00000000e+04]，
#[9.80100000e+03]，
#[9.025000000E+03]，
#[6.24100000e+03]，
#[6.77124832e-09]，
#[2.56541398e-17]]，“jac”：数组（[1.99999886e+02]，
#[1.979907E+02]，
#[1.89999810e+02]，
#[1.57999875e+02]，
#[1.64585190e-04]，
#[-1.29983171e-10]]]
#消息：b'收敛：投影的标准梯度有一个
回调
方法可以使用。请注意，您只能在完成一个完整的迭代步骤后停止。如果你的函数值计算或梯度非常昂贵，你必须考虑到这一点。或者，只允许“少量”的迭代，保存结果，然后用返回的值重新启动。问题是大的，还是复杂的，还是两者都有？问题是大的（100到1000个自变量）和复杂的。我确实可以在少量迭代之后重新启动。然而，它也有它的缺点，因为BFGS算法使用以前迭代中的信息，而这些信息不会超过10次。我不知道如何使用回调函数停止优化。我只是设法提出了一个错误。你能解释一下怎么做吗？
from optimparallel import minimize_parallel
minimize_parallel(fun=fun, x0=np.array([100]), parallel={'loginfo': True})
#      fun: 2.565413976271745e-17
# hess_inv: array([[0.50000039]])
#      jac: array([-1.29983171e-10])
#  loginfo: {'x': array([[ 1.00000000e+02],
#       [ 9.90000000e+01],
#       [ 9.50000000e+01],
#       [ 7.90000000e+01],
#       [ 8.22875951e-05],
#       [-5.06499159e-09]]), 'fun': array([[1.00000000e+04],
#       [9.80100000e+03],
#       [9.02500000e+03],
#       [6.24100000e+03],
#       [6.77124832e-09],
#       [2.56541398e-17]]), 'jac': array([[ 1.99999886e+02],
#       [ 1.97999907e+02],
#       [ 1.89999810e+02],
#       [ 1.57999875e+02],
#       [ 1.64585190e-04],
#       [-1.29983171e-10]])}
#  message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'
#     nfev: 6
#      nit: 3
#   status: 0
#  success: True
#        x: array([-5.06499159e-09])