Skip to main content
 首页 » 编程设计

python之fmin_slsqp 对同一个系统返回不同的解

2025年05月04日14mayingbao

以下是我所能总结的内容。

我正在尝试求解包含 18 个方程和 18 个变量的方程组。目前,我将其中的 4 个变量固定不变。最初,我得到了奇怪的结果。因此,我将问题简化为 前 9 个和后 9 个方程是独立且相同的。而且,问题是明确的:应该有一个唯一的解决方案。

解向量包含 14 个元素(18 个元素减去 4 个固定变量)。由于这些顺序正确,前 7 个解决方案变量应该与最后 7 个解决方案变量相同。然而,他们不是。

  • 我通过放入相同的向量 x[:7] = x[7:] 并检查 res[:9] == res[9:] 来检查方程的恒等式 都是真的。

以下是我得到的输出:

Optimization terminated successfully.    (Exit mode 0) 
            Current function value: 0.125393271845 
            Iterations: 18 
            Function evaluations: 297 
            Gradient evaluations: 18 
Out[223]:  
          J         W         w         v         U         u         Y 
0  0.663134  0.237578  0.251245  10.00126  0.165647  0.093939  0.906657 
1  0.022635  0.825547  1.000000  10.00340  0.512898  0.089790  0.909918 

我将前 7 个变量堆叠到第一行,将接下来的 7 个变量堆叠到第二行。显然,这些并不相同。

复制代码如下

import numpy as np 
 
# parameters 
 
class Parameters(object): 
    r = 1.03 
    sBar = 0.1 
    sB = 0.1 
    c = 0.1 
    z = 0.001 
    H = 1 
    epsilon = 1 
    beta = 0.1 
 
def q(theta): 
    if theta <= 0: 
        return 999 
    return float(1)/theta 
 
def f(theta): 
    if theta < 1: 
        return 0 
    return 1 - float(1)/theta 
 
# sum_all allows to see residual as vector, not summed 
def twoSectorFake(x, Param, sum_all=True): 
    JBar, WBar, wBar, vBar, UBar, uBar, YBar = x[:7] 
    JB, WB, wB, vB, UB, uB, YB = x[7:] 
    VBar = 0 
    VB = 0 
    pB = 1 
    pBar = 1 
    #theta = float(vB + vBar)/u 
    thetaBar = float(vBar)/uBar 
    thetaB = float(vB)/uB 
    res = np.empty(18,) 
    res[0] = Param.r*JBar - (pBar - wBar - Param.sBar*(JBar - VBar) ) 
    res[1] = Param.r * VBar - ( -Param.c + q(thetaBar) * (JBar - VBar) ) 
    res[2] = Param.r * WBar - (wBar - Param.sBar * (WBar - UBar) ) 
    res[3] = Param.r * UBar - (Param.z + f(thetaBar) * (WBar - UBar) ) 
    res[4] = Param.sBar * YBar - vBar * q(thetaBar) 
    res[5] = Param.sBar * YBar - uBar * f(thetaBar) 
    res[6] = JBar - (1 - Param.beta) * (JBar + WBar - UBar) 
    res[7] = Param.H - YBar - uBar 
    res[8] = thetaBar * uBar - vBar 
 
    res[9] = Param.r*JB - (pB - wB - Param.sB*(JB - VB)) 
    res[10] = Param.r*VB - ( -Param.c + q(thetaB) * (JB - VB)) 
    res[11] = Param.r * WB - (wB - Param.sB * (WB - UB)) 
    res[12] = Param.r * UB - (Param.z + f(thetaB) * (WB - UB)) 
    res[13] = Param.sB * YB - vB*q(thetaB) 
    res[14] = Param.sB * YB - uB * f(thetaB) 
    res[15] = JB - (1 - Param.beta) * (JB + WB - UB) 
    res[16] = Param.H - YB - uB 
    res[17] = thetaB * uB - vB 
 
    idx = abs(res > 10000) 
    # don't square too big numbers, they may become INF and the problem won't solve 
    res[idx] = abs(res[idx]) 
    res[~idx] = res[~idx]**2 
    if (sum_all==False): 
        return res 
    return sum(res) 
 
Param = Parameters() 
 
x2 = np.empty(0,) 
boundaries2 = [] 
# JBar 
x2 = np.append(x2, 1) 
boundaries2.append([0, 100]) 
# WBar 
x2 = np.append(x2, 1) 
boundaries2.append([0, 100]) 
# wBar 
x2 = np.append(x2, 0.5) 
boundaries2.append([0.01, 100]) 
# vBar 
x2 = np.append(x2, 10) 
boundaries2.append([0.01, 100000]) 
# UBar 
x2 = np.append(x2, float(Param.z)/(Param.r-1)+1) 
boundaries2.append([float(Param.z)/(Param.r-1) - 0.1, 100]) 
# uBar 
x2 = np.append(x2, 0.5*Param.H) 
boundaries2.append([0.0000001, Param.H]) 
# YBar 
x2 = np.append(x2, 0.5*Param.H) 
boundaries2.append([0.0001, Param.H]) 
# JB 
x2 = np.append(x2, 1) 
boundaries2.append([0, 100]) 
# WB 
x2 = np.append(x2, 1) 
boundaries2.append([0, 100]) 
# wB 
x2 = np.append(x2, 0.5) 
boundaries2.append([1, 100]) 
# vB 
x2 = np.append(x2, 10) 
boundaries2.append([0.01, 100]) 
# UB 
x2 = np.append(x2, float(Param.z)/(Param.r-1)+1) 
boundaries2.append([float(Param.z)/(Param.r-1) - 0.1, 100]) 
# uB 
x2 = np.append(x2, 0.5*Param.H) 
boundaries2.append([0.0000001, Param.H]) 
# YB 
x2 = np.append(x2, 0.5*Param.H) 
boundaries2.append([0.0001, Param.H]) 
 
result = optimize.fmin_slsqp(func=twoSectorFake, x0=x2, bounds=boundaries2, args=(Param,), iter=200) 
res1 = result[:7] 
res2 = result[7:] 
df = pd.DataFrame(np.reshape(res1, (1,7)), columns=['J', 'W', 'w', 'v', 'U', 'u','Y']) 
df.loc[1] = np.reshape(res2, (1,7)) 
print df 

请您参考如下方法:

编辑:

您的变量 boundaries2 不是对称的,即 boundaries2[7:]!=boundaries2[:7]。

尝试写作

boundaries2 = boundaries2[7:]*2 

就在您调用 fmin_slsqp 之前,您会得到一个对称的局部最小值。我将之前对您的设置的一般性评论留在下面,因为它们适用于任何情况。

首先,您确定您的问题只有一种解决方案吗?如果不是,我不会期望 scipy 数值例程一定会返回您想到的解决方案。它可以收敛到任何其他非对称解。

在第二种情况下,您不是在求解方程组。如果您在代码末尾计算 twoSectorFake(result,Param),您将得到 0.15。使用其他根求解器可能会更好,请参阅 root finding部分。

这意味着您正在查看目标函数的局部最小值,即不是零。同样,没有理由认为数值例程必须计算对称局部最小值。