Starke Dualitätsbedingung mithilfe der Pyomo-Bibliothek in Python

Question

Ich implementiere ein Inverses Optimierungsproblem, das anstelle der Verwendung von KKT-Bedingungen den starken Dualitätstheorem anwendet (primäres optimales Ziel und duales optimales Ziel sind gleich). Zu diesem Zweck ist es erforderlich, das ursprüngliche und das duale Problem zu formulieren. Ich habe 4 Generatoren mit je 8 Energieblöcken (b) und eine feste Nachfrage. Dies ist eine Marktbereinigung pro Stunde. Das ursprüngliche Problem ist ein einfacher Markt Clearing und es ist wie folgt unter Verwendung der Bibliothek 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]) 

Lassen Sie sich sagt, dass die früheren Gleichungen benannt sind (1a-1f). Wenn nicht angegeben, wird als Standard festgelegt, um die Zielfunktion zu minimieren. Da das primäre Problem ein Minimierungsproblem ist, muss sein Dual ein Maximierungs-Problem sein. Aber es ist äquivalent max [F (x)] == min [-F (x)], und es ist was ich angewendet habe. Hier ist das duale Problem (Gleichungen 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]) 

Sobald die ursprüngliche und das duale Problem vorgestellt, das eigentliche Problem, das ich habe zu lösen, ist die folgende:

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))) 

hier Ich muss die Einschränkungen aus dem zuvor geschriebenen dualen Problem (2b-2e) angeben und außerdem die strenge Dualitätsbedingung anwenden, die lautet:

min (Zielfunktion primales Problem) = max (Zielfunktion duales Problem)

Hier ist mein Problem: Wie wäre diese letzte Einschränkung geschrieben ??

Answer 1

Nun, ich habe deine Frage nicht wirklich verstanden, und ich kann noch nichts sagen, also schreibe ich eine Antwort, in der Hoffnung, dass es dir helfen würde.

Zunächst einmal in pyomo, wie @Qi Chen erwähnt, können Sie auf die Dual-Werte zugreifen, die von Solver selbst generiert. Dafür benötigen Sie folgende in Ihrem Modell hinzuzufügen:

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

Dann können Sie die Instanz des Modells an anderer Stelle nennen, und Sie können die doppelten Werte der Einschränkungen erhalten, die in Ihrem Modell sind über:

dual_value = inst.dual[inst.constraint_name] 

zB:

dual_con_g1max = inst.dual[inst.con_g1max] 

aber, oFC seit con_g1max ist ein Constraint_List, müssen Sie seinen Index auf die doppelte bekommen algo geben. wie:

inst.dual[inst.con_g1max[1]]