如何正确地使用带有多重变量的scipy最小化？

Question

我想对scipy.optimize.minimize进行五个变量scipy.optimize.minimize ，以便根据A ， B ， C ， D和E来寻找所需的解决方案。 首先，我从scipy导入了minimize并定义了初始猜测（基于实验室实验，因此它们应该是有效的）。

from scipy.optimize import minimize

A0 = 1.90
B0 = 6.40
C0 = 11.7
D0 = 3.70
E0 = 2.50

ABCDE0 = [A0, B0, C0, D0, E0]

其次，我定义了组成目标函数的各个函数，方便地命名为Objective 。 我也尝试将F ， G ， H和I合并为一个函数，但没有任何运气，因此我决定暂时将其保留为这样。

def F(abcde):
    a, b, c, d, e = abcde
    return c - (b ** 2) / (a - e)

def G(abcde):
    a, b, c, d, e = abcde
    return (4 * e * ((a - e) * c - b ** 2)) / (a * c - b ** 2)

def H(abcde):
    a, b, c, d, e = abcde
    return b / (2 * (a - e))

def I(abcde):
    a, b, c, d, e = abcde
    return (2 * e * b) / (a * c - b ** 2)

def Objective(abcde):
    return (F(abcde) / G(abcde)) / (H(abcde) / I(abcde))

第三，为简单起见，我定义了constraint （即(F/G)/(H/I)=1 ），并且将名为bnds的边界bnds为初始猜测的+/- 10% 。

def constraint(x):
    F = x[0]
    G = x[1]
    H = x[2]
    I = x[3]
    return (F / G) / (H / I) - 1

con = {'type': 'eq', 'fun': constraint1}

min_per = 0.9
max_per = 1.1
bnds = ((A0*min_per, A0*max_per), (B0*min_per, B0*max_per), 
        (C0*min_per, C0*max_per), (D0*min_per, D0*max_per), 
        (E0*min_per, E0*max_per))

第四，最后， minimize化为我提供了一种称为sol的解决方案。

sol = minimize(Objective, ABCDE0, method='SLSQP', bounds=bnds, constraints=con1, options={'disp':True})

如果要通过print(sol) ，则会出现以下消息。

Positive directional derivative for linesearch    (Exit mode 8)
            Current function value: 1.0
            Iterations: 18
            Function evaluations: 188
            Gradient evaluations: 14
     fun: 1.0
     jac: array([ 0.00000000e+00,  1.49011612e-08, -7.45058060e-09,  0.00000000e+00,
        0.00000000e+00])
 message: 'Positive directional derivative for linesearch'
    nfev: 188
     nit: 18
    njev: 14
  status: 8
 success: False
       x: array([ 2.09      ,  5.76      , 10.53      ,  4.07      ,  2.50000277])

在我心中的新手， constraint似乎是问题，但我不知道因缺乏有经验的minimize 。

• 我做错了什么？
• 为什么执行不成功？
• 在这种情况下，使用root_scalar建议使用root_scalar更好吗？
• 是否可以将所有单个功能都包含在一个功能中以避免混乱？

请注意， D0和d不包含在任何函数中，但作为5个独立变量之一在大事物方案中很重要。

Answer 1

这里发生了几件事：

首先，出于个人喜好，我可能会将函数F ，...， I保留为多个输入，以避免不得不拆开列表。 目标函数确实需要一个列表作为其参数。 即你可以做类似的事情

def F(a, b, c, d, e):
    return c - (b ** 2) / (a - e)

...

def objective(abcde):
    return (F(*abcde) / G(*abcde)) / (H(*abcde) / I(*abcde))

那只是样式。 更重要的是，您的constraint方法无法完全满足您的要求：据我了解，您想对输入上的函数F ，...， I进行求值，但这永远不会发生； 相反，变量F的值（这是一个不幸的名称，因为它遮盖了函数的名称）最终只是a 。 相反，您会做类似的事情

def constraint(x):
    return (F(*x) / G(*x)) / (H(*x) / I(*x)) - 1

现在， constraint(x)只不过是objective(x) - 1 ，所以您的约束最终表明在可行的解决方案中您的objective必须等于1。 这意味着根本没有进行任何优化：任何可行的解决方案都是最优的。 虽然先验minimize确实会尝试为您找到可行的解决方案，但您尝试使用scipy.optimize某些根查找功能时可能会遇到更多的运气，因为您正在尝试寻找根源功能objective - 1 。

现在，最后，这实际上很简单：无论您定义了什么函数objective ，它的值都等于1，所以任何输入都是可行的解决方案：首先，通过写F = ((ae)c - (b**2))/(ae) ，请注意(a*cb**2) / (4*e*(ae)) 。 然后， (F/G)*I = (2*e*b)/(4*e*(ae)) = b/(2*(ae)) = H ，因此1 = (F/G)*(I/H) = (F/G)/(H/I) 。