离散优化（SOS1 约束）- GEKKO
Discrete Optimization (SOS1 constraint) - GEKKO
我正在尝试在 Python 中使用 GEKKO 定义优化问题，并且我想使用一些具有预定义选项列表的设计变量。此外，每个选择都有相关的成本，并且约束条件是总成本应低于指定限制。
下面是一个常见的 gekko 示例（发现 here），修改后 x1 和 x2 为 sos1。同样根据 x1 和 x2 的 selected 值的索引，我从另一个列表中找到它们的相关成本，并且它们的总和应该小于某个值（约束）。
from gekko import GEKKO
def test(x1,x2,x3,x4):
res = x1*x4*(x1+x2+x3)+x3
return res
def check(x1,x2):
tt = [1,2,3,4,5]
cost = [10,10,10,2,1]
if x1.value in tt:
y1 = tt.index(x1.value)
y2 = tt.index(x2.value)
C = cost[y1]+cost[y2]
return C
return 10
m = GEKKO() # Initialize gekko
m.options.SOLVER=1 # APOPT is an MINLP solver
# optional solver settings with APOPT
m.solver_options = ['minlp_maximum_iterations 500', \
# minlp iterations with integer solution
'minlp_max_iter_with_int_sol 10', \
# treat minlp as nlp
'minlp_as_nlp 0', \
# nlp sub-problem max iterations
'nlp_maximum_iterations 50', \
# 1 = depth first, 2 = breadth first
'minlp_branch_method 1', \
# maximum deviation from whole number
'minlp_integer_tol 0.05', \
# covergence tolerance
'minlp_gap_tol 0.01']
# Integer constraints for x3 and x4
x3 = m.Var(value=1,lb=1,ub=5,integer=True)
x4 = m.Var(value=2,lb=1,ub=5,integer=True)
x1 = m.sos1([1,2,3,4,5])
x2 = m.sos1([1,2,3,4,5])
# Equations
m.Equation(x1*x2*x3*x4>=25)
m.Equation(x1**2+x2**2+x3**2+x4**2==40)
m.Equation(check(x1,x2)<=5)
m.Obj(test(x1,x2,x3,x4)) # Objective
m.solve(disp=False) # Solve
print('Results')
print('x1: ' + str(x1.value))
print('x2: ' + str(x2.value))
print('x3: ' + str(x3.value))
print('x4: ' + str(x4.value))
print('Objective: ' + str(m.options.objfcnval))
注意：我必须在 check 函数中添加一个 if 块作为 x1 的初始值并且 x2 似乎为零。
此代码无效，我收到以下错误。
> Exception has occurred: Exception
@error: Equation Definition
Equation without an equality (=) or inequality (>,<)
true
STOPPING...
我不知道是什么导致了这个错误。我应该如何重新制定我的模型以获得所需的结果？
编辑：此示例代码只是我重现错误的尝试。我的实际应用是设计一个工程系统。例如，假设系统有 2 个组件 - 电池和灯泡。我有两种电池可供选择，电池 A 重 10kg，可靠性为 0.97，电池 B 重 6kg，可靠性为 0.75。同样，灯泡也有不同的选择。我需要 select 电池和灯泡的选择，使整个系统的可靠性尽可能高（objective）并且总重量小于 'x' 千克（约束） .在上面的代码中，将 x1 和 x2 值视为组件的 selected 选择，我找到它们的索引以获取它们关联的 weight/cost（如果 Battery A 和 Bulb B 被选中，我得到他们的重量来检查总重量是否小于允许的限制）。现在我的实际系统有 n 个组件和每个组件的 m 个选项。每个选择都有相关的重量、成本、可靠性等。我试图找到最佳组合，以在系统重量、成本等限制条件下最大限度地提高系统可靠性
我根据您的示例描述构建了一个简单的模型。
from gekko import GEKKO
import numpy as np
m = GEKKO() # Initialize gekko
m.options.SOLVER=1 # APOPT is an MINLP solver
# optional solver settings with APOPT
m.solver_options = ['minlp_maximum_iterations 500', \
# minlp iterations with integer solution
'minlp_max_iter_with_int_sol 10', \
# treat minlp as nlp
'minlp_as_nlp 0', \
# nlp sub-problem max iterations
'nlp_maximum_iterations 50', \
# 1 = depth first, 2 = breadth first
'minlp_branch_method 1', \
# maximum deviation from whole number
'minlp_integer_tol 0.05', \
# covergence tolerance
'minlp_gap_tol 0.01']
x1 = m.Array(m.Var, 5, **{'value':0,'lb':0,'ub':1, 'integer': True}) # battery options
print(f'x1_initial: {x1}')
x2 = m.Array(m.Var, 5, **{'value':0,'lb':0,'ub':1, 'integer': True}) # bulb options
print(f'x2_initial: {x2}')
bat_cost = np.array([ 10, 2, 3, 4, 5]) # battery costs
bat_weigh = np.array([ 1, 25, 20, 19, 20]) # battery weighs
bulb_cost = np.array([ 2, 5, 33, 24, 5]) # bulb costs
bulb_weigh = np.array([ 6, 10, 2, 10, 20]) # bulb weighs
m.Equation( sum(bat_weigh * x1) + sum(bulb_weigh * x2) <= 25) # limit total weigh
m.Equation(m.sum(x1) == 1) # restrict choice to a single battery
m.Equation(m.sum(x2) == 1) # restrict choice to a single bulb
m.Obj( sum(bat_cost * x1) + sum(bulb_cost * x2) ) # Objective
m.solve(disp=False) # Solve
print('Results:')
print(f'x1: {x1}')
print(f'x2: {x2}')
print(f'battery cost: {sum(np.array([i[0] for i in x1]) * bat_cost)}')
print(f'battery weigh: {sum(np.array([i[0] for i in x1]) * bat_weigh)}')
print(f'bulb cost: {sum(np.array([i[0] for i in x2]) * bulb_cost)}')
print(f'bulb weigh: {sum(np.array([i[0] for i in x2]) * bulb_weigh)}')
print('Objective value: ' + str(m.options.objfcnval))
结果如下：
x1_initial: [0 0 0 0 0]
x2_initial: [0 0 0 0 0]
Results:
x1: [[0.0] [0.0] [0.0] [1.0] [0.0]]
x2: [[1.0] [0.0] [0.0] [0.0] [0.0]]
battery cost: 4.0
battery weigh: 19.0
bulb cost: 2.0
bulb weigh: 6.0
Objective value: 6.0
这是一个非常简单的示例，展示了如何表示电池和灯泡信息。它可以变得更复杂，但我需要更多细节并理解为什么你有多项式方程，它们代表什么。
重申一下，您遇到的错误与以下行有关：
m.Equation(check(x1,x2)<=5)
除了 user7440787 的好答案之外，您还需要从一组预定义的离散设计变量中查找多个值。除了使用预定义的 m.SOS1() 函数，您还可以使用类似下面的方法将一个二元决策变量数组与多个相关性或变量相关联。
from gekko import GEKKO
m = GEKKO(remote=False)
# design variable
y = m.Var(lb=1,ub=5)
# options
n = 4
# weight
weight=[19.05-y, 25.0-0.1*y**2, 29.3-0.02*y**3, 30.2]
# cost
cost = [3.2+y,2.4+0.01*y**2,1.6+y+0.001*y**3,5.2]
# SOS1 with binary variables
b = m.Array(m.Var,n,lb=0,ub=1,integer=True)
m.Equation(m.sum(b)==1) # only select one
# cost x weight
cxw = m.sum([b[i]*cost[i]*weight[i] for i in range(4)])
# minimize cost x weight
m.Minimize(cxw)
# change to APOPT solver
m.options.SOLVER = 1
m.solve(disp=False)
print('Design Variable: ' + str(y.value[0]))
print('Option: ' + str(b))
在此示例中，您有一个设计变量 y 和基于设计变量的 cost 和 weight 的不同方程。整体objective是在调整y.
的同时最小化cost和weight的乘积
我正在尝试在 Python 中使用 GEKKO 定义优化问题，并且我想使用一些具有预定义选项列表的设计变量。此外，每个选择都有相关的成本，并且约束条件是总成本应低于指定限制。
下面是一个常见的 gekko 示例（发现 here），修改后 x1 和 x2 为 sos1。同样根据 x1 和 x2 的 selected 值的索引，我从另一个列表中找到它们的相关成本，并且它们的总和应该小于某个值（约束）。
from gekko import GEKKO
def test(x1,x2,x3,x4):
res = x1*x4*(x1+x2+x3)+x3
return res
def check(x1,x2):
tt = [1,2,3,4,5]
cost = [10,10,10,2,1]
if x1.value in tt:
y1 = tt.index(x1.value)
y2 = tt.index(x2.value)
C = cost[y1]+cost[y2]
return C
return 10
m = GEKKO() # Initialize gekko
m.options.SOLVER=1 # APOPT is an MINLP solver
# optional solver settings with APOPT
m.solver_options = ['minlp_maximum_iterations 500', \
# minlp iterations with integer solution
'minlp_max_iter_with_int_sol 10', \
# treat minlp as nlp
'minlp_as_nlp 0', \
# nlp sub-problem max iterations
'nlp_maximum_iterations 50', \
# 1 = depth first, 2 = breadth first
'minlp_branch_method 1', \
# maximum deviation from whole number
'minlp_integer_tol 0.05', \
# covergence tolerance
'minlp_gap_tol 0.01']
# Integer constraints for x3 and x4
x3 = m.Var(value=1,lb=1,ub=5,integer=True)
x4 = m.Var(value=2,lb=1,ub=5,integer=True)
x1 = m.sos1([1,2,3,4,5])
x2 = m.sos1([1,2,3,4,5])
# Equations
m.Equation(x1*x2*x3*x4>=25)
m.Equation(x1**2+x2**2+x3**2+x4**2==40)
m.Equation(check(x1,x2)<=5)
m.Obj(test(x1,x2,x3,x4)) # Objective
m.solve(disp=False) # Solve
print('Results')
print('x1: ' + str(x1.value))
print('x2: ' + str(x2.value))
print('x3: ' + str(x3.value))
print('x4: ' + str(x4.value))
print('Objective: ' + str(m.options.objfcnval))
注意：我必须在 check 函数中添加一个 if 块作为 x1 的初始值并且 x2 似乎为零。
此代码无效，我收到以下错误。
> Exception has occurred: Exception
@error: Equation Definition
Equation without an equality (=) or inequality (>,<)
true
STOPPING...
我不知道是什么导致了这个错误。我应该如何重新制定我的模型以获得所需的结果？
编辑：此示例代码只是我重现错误的尝试。我的实际应用是设计一个工程系统。例如，假设系统有 2 个组件 - 电池和灯泡。我有两种电池可供选择，电池 A 重 10kg，可靠性为 0.97，电池 B 重 6kg，可靠性为 0.75。同样，灯泡也有不同的选择。我需要 select 电池和灯泡的选择，使整个系统的可靠性尽可能高（objective）并且总重量小于 'x' 千克（约束） .在上面的代码中，将 x1 和 x2 值视为组件的 selected 选择，我找到它们的索引以获取它们关联的 weight/cost（如果 Battery A 和 Bulb B 被选中，我得到他们的重量来检查总重量是否小于允许的限制）。现在我的实际系统有 n 个组件和每个组件的 m 个选项。每个选择都有相关的重量、成本、可靠性等。我试图找到最佳组合，以在系统重量、成本等限制条件下最大限度地提高系统可靠性
我根据您的示例描述构建了一个简单的模型。
from gekko import GEKKO
import numpy as np
m = GEKKO() # Initialize gekko
m.options.SOLVER=1 # APOPT is an MINLP solver
# optional solver settings with APOPT
m.solver_options = ['minlp_maximum_iterations 500', \
# minlp iterations with integer solution
'minlp_max_iter_with_int_sol 10', \
# treat minlp as nlp
'minlp_as_nlp 0', \
# nlp sub-problem max iterations
'nlp_maximum_iterations 50', \
# 1 = depth first, 2 = breadth first
'minlp_branch_method 1', \
# maximum deviation from whole number
'minlp_integer_tol 0.05', \
# covergence tolerance
'minlp_gap_tol 0.01']
x1 = m.Array(m.Var, 5, **{'value':0,'lb':0,'ub':1, 'integer': True}) # battery options
print(f'x1_initial: {x1}')
x2 = m.Array(m.Var, 5, **{'value':0,'lb':0,'ub':1, 'integer': True}) # bulb options
print(f'x2_initial: {x2}')
bat_cost = np.array([ 10, 2, 3, 4, 5]) # battery costs
bat_weigh = np.array([ 1, 25, 20, 19, 20]) # battery weighs
bulb_cost = np.array([ 2, 5, 33, 24, 5]) # bulb costs
bulb_weigh = np.array([ 6, 10, 2, 10, 20]) # bulb weighs
m.Equation( sum(bat_weigh * x1) + sum(bulb_weigh * x2) <= 25) # limit total weigh
m.Equation(m.sum(x1) == 1) # restrict choice to a single battery
m.Equation(m.sum(x2) == 1) # restrict choice to a single bulb
m.Obj( sum(bat_cost * x1) + sum(bulb_cost * x2) ) # Objective
m.solve(disp=False) # Solve
print('Results:')
print(f'x1: {x1}')
print(f'x2: {x2}')
print(f'battery cost: {sum(np.array([i[0] for i in x1]) * bat_cost)}')
print(f'battery weigh: {sum(np.array([i[0] for i in x1]) * bat_weigh)}')
print(f'bulb cost: {sum(np.array([i[0] for i in x2]) * bulb_cost)}')
print(f'bulb weigh: {sum(np.array([i[0] for i in x2]) * bulb_weigh)}')
print('Objective value: ' + str(m.options.objfcnval))
结果如下：
x1_initial: [0 0 0 0 0]
x2_initial: [0 0 0 0 0]
Results:
x1: [[0.0] [0.0] [0.0] [1.0] [0.0]]
x2: [[1.0] [0.0] [0.0] [0.0] [0.0]]
battery cost: 4.0
battery weigh: 19.0
bulb cost: 2.0
bulb weigh: 6.0
Objective value: 6.0
这是一个非常简单的示例，展示了如何表示电池和灯泡信息。它可以变得更复杂，但我需要更多细节并理解为什么你有多项式方程，它们代表什么。
重申一下，您遇到的错误与以下行有关：
m.Equation(check(x1,x2)<=5)
除了 user7440787 的好答案之外，您还需要从一组预定义的离散设计变量中查找多个值。除了使用预定义的 m.SOS1() 函数，您还可以使用类似下面的方法将一个二元决策变量数组与多个相关性或变量相关联。
from gekko import GEKKO
m = GEKKO(remote=False)
# design variable
y = m.Var(lb=1,ub=5)
# options
n = 4
# weight
weight=[19.05-y, 25.0-0.1*y**2, 29.3-0.02*y**3, 30.2]
# cost
cost = [3.2+y,2.4+0.01*y**2,1.6+y+0.001*y**3,5.2]
# SOS1 with binary variables
b = m.Array(m.Var,n,lb=0,ub=1,integer=True)
m.Equation(m.sum(b)==1) # only select one
# cost x weight
cxw = m.sum([b[i]*cost[i]*weight[i] for i in range(4)])
# minimize cost x weight
m.Minimize(cxw)
# change to APOPT solver
m.options.SOLVER = 1
m.solve(disp=False)
print('Design Variable: ' + str(y.value[0]))
print('Option: ' + str(b))
在此示例中，您有一个设计变量 y 和基于设计变量的 cost 和 weight 的不同方程。整体objective是在调整y.
cost和weight的乘积