python - Scipy.optimize.minimize() 非线性目标的两个数组

Question

我已经拟合了一个对数正态模型，现在我想使用该模型中的系数来找到将提供最大响应的变量值的组合。我打算稍后引入一些约束，但现在我只想让优化运行。复杂的问题是该模型是一个混合方法模型，所以我有模型中每个人的系数。因此，我需要优化每个人的变量值，给定他们各自的系数。
我的例子:

import numpy as np
from scipy.optimize import minimize

def objective(x, beta):
    x1, x2 = x
    beta1, beta2 = beta
    return -1 * np.sum(np.exp(3 + x1*beta1 + x2*beta2))

# initial guesses for variables x1 and x2
n = 2
x1 = np.zeros(n)
x1[0] = 1.0
x1[1] = 2.0

x2 = np.zeros(n)
x2[0] = 3.0
x2[1] = 4.0

x0 = np.vstack((x1,x2))

# the coefficients (weights) for each of n individuals, in each variable
beta1 = np.zeros(n)
beta1[0] = 1.1
beta1[1] = 1.01

beta2 = np.zeros(n)
beta2[0] = 1.1
beta2[1] = 1.01

beta0 = np.vstack((beta1, beta2))

# show initial objective
print('Initial SSE Objective: ' + str(objective(x0, beta0)))  # this works as intended

# but I'm not sure how to specify bounds given my shape
b = (1.0,5.0)  #min = 1, max = 5 on any one channel for any one individual
bnds = (b, b)

# running without bounds
solution = minimize(objective, x0, method='SLSQP',
                    args=beta0)

...给出以下错误；

  File "<ipython-input-92-554f967ca90b>", line 2, in objective
    x1, x2 = x

ValueError: too many values to unpack (expected 2)

鉴于目标函数在我将参数传递给它时起作用，这是最小化()的限制吗？该函数是否无法采用 x 的形状 (2,2)？
另外，我很难正确指定边界......

# running with bounds
solution = minimize(objective, x0, method='SLSQP',
                    args=beta0, bounds=bnds)

...给出错误；

ValueError: operands could not be broadcast together with shapes (4,) (2,) (2,) 

我能够用 Gekko 做到这一点 DOCS HERE

    from gekko import GEKKO
    m = GEKKO() # Initialize gekko
    n = 2
    
    # Init the coefficients for each HCP
    alpha_list = np.random.normal(3, 0.1, n)
    beta1_list = np.random.normal(1.01, 0.1, n)
    beta2_list = np.random.normal(1.02, 0.1, n)
    beta3_list = np.random.normal(1.04, 0.1, n)
    
    # Initialize variables
    x1 = [m.Var(value=1,lb=0,ub=4) for i in range(n)]
    x2 = [m.Var(value=1,lb=0,ub=4) for i in range(n)]
    x3 = [m.Var(value=1,lb=0,ub=4) for i in range(n)]
    
    # Init the coefficients
    alpha = [m.Const(value=alpha_list[i]) for i in range(n)]
    beta1 = [m.Const(value=beta1_list[i]) for i in range(n)]
    beta2 = [m.Const(value=beta2_list[i]) for i in range(n)]
    beta3 = [m.Const(value=beta3_list[i]) for i in range(n)]
    
    # Inequality constraints
    m.Equation(m.sum(x1) + m.sum(x2) + m.sum(x3) <= n*10)
    
    m.Obj(-1 * m.sum([m.exp(alpha[i] + x1[i]*beta1[i] + x2[i]*beta2[i] + x3[i]*beta3[i]) for i in range(n)])) # Objective
    m.options.IMODE = 3 # Steady state optimization set to 3, change to 1 for integer
    m.options.MAX_ITER = 1000
    m.solve() # Solve
    print('Results')
    print('x1: ' + str(x1))
    print('x2: ' + str(x2))
    print('x3: ' + str(x3))

...但为了我自己的学习，我也希望能够用 scipy 做到这一点。

Answer 1

我正在报告，以防其他人遇到同样的问题。我认为限制是从最小化到目标函数的输入必须是一个平面数组，所以我的 (2,2) 形状不起作用(如果我错了，请纠正我)。
因此，一种解决方法是输入一个平面数组，然后将其解包到目标函数本身中。如果您将函数传递给期望的个体数量，该函数可以处理数组，以便每个 channel 获得 1xN 作为我们尝试优化的回归方程的输入。

import numpy as np
from scipy.optimize import minimize

def objective(x, beta, n):
    x1, x2 = x.reshape(2,n)
    beta1, beta2 = beta.reshape(2,n)
    return -1 * np.sum(np.exp(3 + x1*beta1 + x2*beta2))

# initial guesses for variables x1 and x2
n = 2
x1 = np.zeros(n)
x1[0] = 1.0
x1[1] = 2.0

x2 = np.zeros(n)
x2[0] = 3.0
x2[1] = 4.0

x0 = np.concatenate((x1,x2))

# the coefficients (weights) for each of n individuals, in each variable
beta1 = np.zeros(n)
beta1[0] = 1.1
beta1[1] = 1.01

beta2 = np.zeros(n)
beta2[0] = 1.1
beta2[1] = 1.01

beta0 = np.concatenate((beta1, beta2))

# show initial objective
print('Initial SSE Objective: ' + str(objective(x0, beta0, 2)))  # this works as intended

# specifying bounds is much easier now we just have a flat array
b = (1.0,5.0)  #min = 1, max = 5 on any one channel for any one individual
bnds = (b , b)*n

# running with bounds
solution = minimize(objective, x0, method='SLSQP',
                    args=(beta0,n), bounds=bnds)
x = solution.x

# show final objective
print('Final SSE Objective: ' + str(objective(x, beta0, n)))

# print solution
print('Solution')
x_sol = x.reshape(2,n)
print('x1 = ' + str(x_sol[0]))
print('x2 = ' + str(x_sol[1]))

正如预期的那样，在没有约束的情况下，最小化调用只会最大化方程中每个变量的值。我的下一步将是对这个函数施加约束。