在Python中使用Pyomo库的强对偶约束

Question

我正在实现逆优化问题而不是使用KKT条件应用强对偶定理（原始最优目标和双最优目标是相等的）。为此，需要制定原始和双重问题。我有4个发电机，每个发电机有8个能量块（b）和固定需求。这是每小时的市场清算。原始问题是一个简单的市场清算，使用库Pyomo如下：

model = ConcreteModel()
model.g1=Var(b, within=NonNegativeReals)
model.g2=Var(b, within=NonNegativeReals)
model.g3=Var(b, within=NonNegativeReals)
model.g4=Var(b, within=NonNegativeReals)

model.obj = Objective(expr=
                      (sum(g1price[i]*model.g1[i] for i in b)+
                       sum(g2price[i]*model.g2[i] for i in b)+
                       sum(g3price[i]*model.g3[i] for i in b)+
                       sum(g4price[i]*model.g4[i] for i in b)))
model.con_power_balance=Constraint(
                      expr=
                      (sum(model.g1[i] for i in b)+
                       sum(model.g2[i] for i in b)+
                       sum(model.g3[i] for i in b)+
                       sum(model.g4[i] for i in b)- demand) == 0)


model.con_g1max=ConstraintList()
for i in b:
    model.con_g1max.add(model.g1[i] <= gsize[i])
model.con_g2max=ConstraintList()
for i in b:
    model.con_g2max.add(model.g2[i] <= gsize[i])
model.con_g3max=ConstraintList()
for i in b:
    model.con_g3max.add(model.g3[i]< = gsize[i])
model.con_g4max=ConstraintList()
for i in b:
    model.con_g4max.add(model.g4[i] <= gsize[i])

假设先前的等式被命名为（1a-1f）。如果没有声明，则设置为默认最小化目标函数。由于原始问题是最小化问题，其对偶必须是最大化问题。但它相当于max [F（x）] == min [-F（x）]，这就是我所应用的。这是双重问题（方程式2a-2e）：

model = ConcreteModel()
model.mu_g1max=Var(b, within=NonNegativeReals)
model.mu_g2max=Var(b, within=NonNegativeReals)
model.mu_g3max=Var(b, within=NonNegativeReals)
model.mu_g4max=Var(b, within=NonNegativeReals)
model.mu_g1min=Var(b, within=NonNegativeReals)
model.mu_g2min=Var(b, within=NonNegativeReals)
model.mu_g3min=Var(b, within=NonNegativeReals)
model.mu_g4min=Var(b, within=NonNegativeReals)
model.lambda=Var(b, within=NonNegativeReals)

model.obj = Objective(expr=
                      (sum(gsize[i]*model.mu_g1max[i] for i in b)+
                       sum(gsize[i]*model.mu_g2max[i] for i in b)+
                       sum(gsize[i]*model.mu_g3max[i] for i in b)+
                       sum(gsize[i]*model.mu_g4max[i] for i in b))

model.con_g1_dual=ConstraintList()
for i in b:
    model.con_g1_dual.add(model.lambda[i]+model.mu_g1min[i]-model.mu_g1max <= gsize[i])
model.con_g2_dual=ConstraintList()
for i in b:
    model.con_g2_dual.add(model.lambda[i]+model.mu_g2min[i]-model.mu_g2max <= gsize[i])
model.con_g3_dual=ConstraintList()
for i in b:
    model.con_g3_dual.add(model.lambda[i]+model.mu_g3min[i]-model.mu_g3max <= gsize[i])
model.con_g4_dual=ConstraintList()
for i in b:
    model.con_g4_dual.add(model.lambda[i]+model.mu_g4min[i]-model.mu_g4max <= gsize[i])

一旦提出原始和双重问题，我必须解决的真正问题是以下问题：

model = ConcreteModel()
model.lambda=Var(b, within=NonNegativeReals)
model.obj = Objective(expr=
                      np.absolute(sum(model.lambda[i]-lambda_ini[i] for i in b*4)))

在这里，我必须将之前编写的双重问题（2b-2e）作为约束，并且应用强对偶约束，它将是：

min（目标函数原始问题）= max（目标函数对偶问题）

这是我的问题：这最后一个约束怎么写？

Answer 1

好吧，我真的不明白你的问题，我还不能评论，所以我发布了一个答案，希望它对你有所帮助。

首先在pyomo中，就像@Qi Chen提到的那样，你可以访问由求解器本身生成的双重值。为此，您需要在模型中添加以下内容：

model.dual = Suffix(direction=Suffix.IMPORT)

然后你可以在其他地方调用模型的实例，你可以通过以下方式获得模型内部约束的双重值：

dual_value = inst.dual[inst.constraint_name]

e.f.:

dual_con_g1max = inst.dual[inst.con_g1max]

但是，因为con_g1max是Constraint_List，你需要给它的双重算法指数。喜欢：

inst.dual[inst.con_g1max[1]]