Mise à jour de ConstraintList à la volée dans Pyomo

Question

Je suis en train de coder une décomp. algorithme en python avec pyomo. Ma question est comme vous pouvez le voir ci-dessous à l'étape 1, que j'ai besoin de trouver un moyen de mettre à jour la contrainte ajoutée d'une manière ou d'une autre, plutôt que de supprimer et d'ajouter une nouvelle contrainte au sous-problème.

Y at-il une manière élégante?

Quelque chose comme

s.Cut_Defn [1] .update (sx == mxvalue)

ou

s.Cut_Defn [1] .pop

s.Cut_Defn. add (sx == mxvalue)

???

Icedkk

Ps: À l'étape 0, j'ajouter une contrainte à la constraintlist de sous-problème. À l'étape 1, je veux réellement mettre à jour la contrainte ajoutée à l'étape 0, mais je ne pouvais pas le faire, donc je supprime la première contrainte ajoutée et j'ajoute la suivante, ce qui est un peu mauvais pour coder.

import sys 
from pyomo.opt.base import SolverFactory 
from pyomo.core import * 
import pyomo.environ 
import numpy as np 
import timeit 

# Importing Models 
from master import m 
from sub import s 

# Misc. init. 

start = timeit.default_timer() 
GAP = float('Inf') 
maxit = 5 

################################### 
# STEP 0: Init. 

opt = SolverFactory('glpk') 

results_M = opt.solve(m)   # solve master 

s.Cut_Defn.add(s.x == m.x.value) # s.x = m.x.value 

results_S = opt.solve(s)   # solve sub 

print('i','\t','Mx','\t','Sx','\t','Ma','\t','Sy',\ 
      '\t','Lmda','\t','Zup','\t','Zdo','\t','Gap',\ 
      '\t','Objective') 

####################################################################### 
# Benders Loop  

for i in sequence(maxit): 

    ################################### 
    # STEP 1: Subproblem Solution 
    if i == 1: 
     pass 
    else: 
     del s.Cut_Defn[i-1] 
     s.Cut_Defn.add(s.x == m.x.value) 
     results_S = opt.solve(s) 

    ################################### 
    # Adding the Master Cut 

    Lambda = s.dual[s.Cut_Defn[i]]   # get Lambda from Solver 

    m.Cut_Defn.add(s.Obj() + float(Lambda)*(m.x-s.x.value) <= m.a) # add Cut to Master 

    ################################### 
    # STEP 2: Convergence Checking 

    Zup = s.Obj() - s.x.value/4 
    Zdo = m.Obj() 

    newGAP = Zup - Zdo 

    if newGAP > 0.00001: 
     GAP = min(GAP, newGAP) 
    else: 
     print(i,'\t',round(m.x.value,1),'\t',round(s.x.value,1),'\t',round(m.a.value,1),'\t',round(s.y.value,1),\ 
       '\t',round(Lambda,2),'\t',round(Zup,1),'\t',round(Zdo,1),'\t',round(newGAP,2),\ 
       '\t',round(m.Obj(),5)) 
     break 

    ################################### 
    # STEP 3: Re-Solve Masterproblem 

    print(i,'\t',round(m.x.value,1),'\t',round(s.x.value,1),'\t',round(m.a.value,1),'\t',round(s.y.value,1),\ 
      '\t',round(Lambda,2),'\t',round(Zup,1),'\t',round(Zdo,1),'\t',round(GAP,2),\ 
      '\t',round(m.Obj(),5)) 

    #solve_all_instances(solver_manager, 'cplex', [Instance_M]) 
    results_M = opt.solve(m) 

stop = timeit.default_timer() 
print("Benders converged in", round(stop-start,2),"s.") 

Answer 1

Vous pouvez générer des contraintes qui peuvent être mises à jour ultérieurement à l'aide de l'objet Expression ou d'un paramètre modifiable. Un paramètre mutable vous permet de mettre à jour un coefficient ou rhs, alors qu'une expression vous permet de mettre à jour une sous-expression d'une contrainte. Exemple:

model = ConcreteModel() 
model.p = Param(mutable=True) 
model.e = Expression() 
model.x = Var() 
model.c = Constraint(expr=model.e == model.p) 
# set the constraint rhs to 1 
model.p.value = 1 
# set the constraint lhs to x**2 
model.e.expr = model.x**2 

Notez que vous ne devez pas utiliser une expression pour stocker une expression relationnelle (par exemple, ==, >=, <=).