Résolution de MINLP avec Pyomo. Y a-t-il un paramètre sur "Démarrage de la solution faisable"?

Question

Mon environnement est: Python 3.5.2, 4.2.0 Anaconda (32 bits), Pyomo 4.4.1 (VOTD) (CPython 3.5.2 W7), le baron 17.3.31

que je fais actuellement optimisation avec Pyomo et Baron comme solveur. Pour tester, un problème minlp est utilisé. Je peux obtenir la solution optimale en exécutant le code main.py comme suit. Chaque fois que je lance le code, après la première exécution, j'obtiens la même solution que la première fois. Le résultat affiche:

La solution de départ est faisable avec une valeur de xxxxx
Faire la recherche locale
Solving bondissant LP
Démarrage multi-démarrage recherche locale
Fait avec la recherche locale

La solution de départ réalisable sera la même à chaque fois. Cependant, après avoir redémarré le noyau (redémarrer le Spyder) et réexécuté le fichier, il peut obtenir la solution différente. POURQUOI? Y a-t-il une méthode pour réinitialiser le processus d'optimisation? Comment puis-je obtenir les différentes solutions sans redémarrer le noyau?

I'v fait quelques essayer: imp.reload (pyomo.environ), imp.reload (pyomo.opt) ... etc

S'il vous plaît aider. Je vous remercie.

Le fichier principal main.py est comme ci-dessous:

from pyomo.environ import * 
from pyomo.opt import SolverFactory 
from minlp import model 


instance = model.create_instance() 
instance.dual = Suffix(direction=Suffix.IMPORT) 
minlpopt = SolverFactory("baron") 
results = minlpopt.solve(instance, tee=True) 
print('Objective Fucntion: ' + str(instance.obj())) 

Le fichier modèle minlp.py est comme ci-dessous:

from pyomo.environ import * 

# SETS ======================================================================== 
model = ConcreteModel() 

model.y1 = Var(within=Binary) 
model.y2 = Var(within=Binary) 
model.y3 = Var(within=Binary) 
model.x1 = Var(within=PositiveReals, bounds=(0,2)) 
model.x2 = Var(within=PositiveReals, bounds=(0,2)) 
model.x3 = Var(within=PositiveReals, bounds=(0,1)) 


# RULE ======================================================================== 
def obj_rule(model): 
    return (5 * model.y1 + 6 * model.y2 + 8 * model.y3 + 10 * model.x1 \ 
      - 7 * model.x3 - 18 * log(model.x2 + 1) \ 
      - 19.2 * log(model.x1 - model.x2 + 1) + 10) 
model.obj = Objective(rule=obj_rule, sense=minimize) 


def c1_rule(model): 
    return (0.8 * log(model.x2 + 1) + 0.96 * log(model.x1 - model.x2 + 1) \ 
      - 0.8 * model.x3) >= 0 
model.c1 = Constraint(rule=c1_rule) 

def c2_rule(model): 
    return (log(model.x2 + 1) + 1.2 * log(model.x1 - model.x2 + 1) - model.x3 \ 
      - 2 * model.y3) >= -2 
model.c2 = Constraint(rule=c2_rule) 

def c3_rule(model): 
    return model.x2 - model.x1 <= 0 
model.c3 = Constraint(rule=c3_rule) 

def c4_rule(model): 
    return model.x2 - 2 * model.y1 <= 0 
model.c4 = Constraint(rule=c4_rule) 

def c5_rule(model): 
    return model.x1 - model.x2 - 2 * model.y2 <= 0 
model.c5 = Constraint(rule=c5_rule) 

def c6_rule(model): 
    return model.y1 + model.y2 <= 1 
model.c6 = Constraint(rule=c6_rule) 

Answer 1

Si vous ajoutez keepfiles=True à l'appel solve(), il imprimera sur le fichier temporaire .bar qui est envoyé à Baron (notez que nous prenons également en charge l'interface de fichier NL de Baron, qui nécessite le solveur baron_ampl). En outre, l'ajout de symbolic_solver_labels=True rendra ce fichier un peu plus facile à lire en utilisant les noms d'origine des objets sur le modèle pour écrire le fichier.

Je recommanderais de différencier ces fichiers à chaque itération pour différentes exécutions. Si, par exemple, le fichier .bar à la première itération est le même pour deux exécutions différentes mais que les solutions sont différentes après cette itération, cela signifie que le comportement non déterministe est à l'intérieur de Baron (il existe peut-être une option Baron pour le contrôler) . Sinon, recherchez des endroits dans votre code où l'ordre d'itération peut changer d'une instance à l'autre, ce qui peut entraîner des résultats différents pour certaines opérations (par exemple, les endroits où vous parcourez les clés d'un dictionnaire).

Le comportement par défaut des solveurs Pyomo est généralement suffisant pour rendre les fichiers de sortie identiques pour les modèles équivalents. Si ce n'est pas le cas, c'est probablement parce que les objets ne sont pas ajoutés aux blocs parents dans le même ordre. Dans ce cas, vous pouvez essayer d'ajouter file_determinism=3 à l'appel solve() pour les solveurs basés sur des fichiers. Cela entraînera un tri supplémentaire avant que le fichier ne soit écrit, ce qui garantit que le fichier de sortie est toujours le même.