instancier un modèle concret à partir d'un modèle pyomo abstrait

Question

J'essaie de créer un modèle abstrait dans Pyomo 5.1.1, puis de le remplir avec des valeurs dans python (c'est-à-dire sans utiliser les fichiers AMPL). Je suis fondamentalement en train de suivre le Pyomo documentation example, mais j'obtiens un "objectif constant détecté".

import pyomo.environ as oe 
model = oe.AbstractModel() 
model.I = oe.Set() 
model.J = oe.Set() 
model.a = oe.Param(model.I,model.J) 
model.b = oe.Param(model.I) 
model.c = oe.Param(model.J) 
model.x = oe.Var(model.J,domain=oe.NonNegativeReals) 
def obj_expression(model): 
    return oe.summation(model.c,model.x) 

model.OBJ = oe.Objective(rule=obj_expression) 
def ax_constraint_rule(model,i): 
    return sum(model.a[i,j]*model.x[j] for j in model.J) >= model.b[i] 

model.AxbConstraint = oe.Constraint(model.I,rule=ax_constraint_rule) 

Et puis, j'essaie d'initialiser ce modèle avec des valeurs réelles

aa = np.array([[1,2,1,4],[5,2,2,4]]) 
bb = np.array([2,4]) 
cc = np.array([1,2,4,2]) 

cmodel = model.create_instance() 
cmodel.a.values = aa 
cmodel.b.values = bb 
cmodel.c.values = cc 

opt = oe.SolverFactory("glpk") 
results = opt.solve(cmodel) 

Je reçois l'erreur suivante:

WARNING:pyomo.core:Constant objective detected, replacing with a placeholder to prevent solver failure. WARNING:pyomo.core:Empty constraint block written in LP format - solver may error WARNING: Constant objective detected, replacing with a placeholder to prevent solver failure. WARNING: Empty constraint block written in LP format - solver may error

De toute évidence, il y a quelque chose de mal dans la façon dont je suis initialisation cmodel mais je ne trouve aucune documentation décrivant l'initialisation dans python.

Answer 1

Si vous n'avez pas besoin de charger vos données à partir de fichiers AMPL .dat, je recommanderais de commencer par un ConcreteModel. Dans ce cas, il n'est pas nécessaire de stocker des données dans les objets Param sauf si vous avez besoin qu'ils soient modifiables. La création d'objets Set pour l'indexation de composants est toujours conseillée; sinon, les objets Set seront créés implicitement avec des noms susceptibles d'entrer en conflit avec les composants que vous ajoutez au modèle. En plaçant votre définition ConcreteModel dans une fonction qui prend en entrée des données, vous dupliquez essentiellement la fonctionnalité fournie par AbstractModel et sa méthode create_instance. Par exemple,

import pyomo.environ as oe 

def build_model(a, b, c): 
    m = len(b) 
    n = len(c) 
    model = oe.ConcreteModel() 
    model.I = oe.Set(initialize=range(m)) 
    model.J = oe.Set(initialize=range(n)) 
    model.x = oe.Var(model.J,domain=oe.NonNegativeReals) 

    model.OBJ = oe.Objective(expr= oe.summation(c,model.x)) 
    def ax_constraint_rule(model,i): 
     arow = a[i] 
     return sum(arow[j]*model.x[j] for j in model.J) >= b[i] 
    model.AxbConstraint = oe.Constraint(model.I,rule=ax_constraint_rule) 
    return model 

# Note that there is no need to call create_instance on a ConcreteModel 
m = build_model(...) 
opt = oe.SolverFactory("glpk") 
results = opt.solve(m) 

En outre, il est conseillé d'abord convertir tous les tableaux NumPy aux listes Python en utilisant la méthode array.tolist() avant de les utiliser pour construire des expressions Pyomo. Pyomo n'a pas encore le concept des opérations de tableau intégrées dans son système d'expression, et l'utilisation des tableaux Numpy comme vous les utilisez peut être beaucoup plus lente que de simplement utiliser des listes Python.