Add more judicious enforcement of PyROS Solver time limit

pyomo/contrib/pyros/CHANGELOG.txt

@@ -2,6 +2,12 @@
 PyROS CHANGELOG
 ===============
 
+-------------------------------------------------------------------------------
+PyROS 1.2.6    07 Dec 2022
+-------------------------------------------------------------------------------
+- Add more judicious enforcement of PyROS time limit.
+
+
 -------------------------------------------------------------------------------
 PyROS 1.2.5    06 Dec 2022
 -------------------------------------------------------------------------------

pyomo/contrib/pyros/master_problem_methods.py

@@ -6,12 +6,16 @@
                              Objective, Constraint,
                              ConstraintList, SortComponents)
 from pyomo.opt import TerminationCondition as tc
+from pyomo.opt import SolverResults
 from pyomo.core.expr import value
 from pyomo.core.base.set_types import NonNegativeIntegers, NonNegativeReals
 from pyomo.contrib.pyros.util import (selective_clone,
                                       ObjectiveType,
                                       pyrosTerminationCondition,
                                       process_termination_condition_master_problem,
+                                      adjust_solver_time_settings,
+                                      revert_solver_max_time_adjustment,
+                                      get_main_elapsed_time,
                                       output_logger)
 from pyomo.contrib.pyros.solve_data import (MasterProblemData,
                                             MasterResult)
@@ -241,6 +245,11 @@ def solve_master_feasibility_problem(model_data, config):
     else:
         solver = config.local_solver
 
+    orig_setting, custom_setting_present = adjust_solver_time_settings(
+        model_data.timing,
+        solver,
+        config,
+    )
     try:
         results = solver.solve(model, tee=config.tee, load_solutions=False)
     except ApplicationError:
@@ -253,6 +262,13 @@ def solve_master_feasibility_problem(model_data, config):
             f"{model_data.iteration}"
         )
         raise
+    finally:
+        revert_solver_max_time_adjustment(
+            solver,
+            orig_setting,
+            custom_setting_present,
+            config,
+        )
 
     feasible_terminations = {
         tc.optimal, tc.locallyOptimal, tc.globallyOptimal, tc.feasible
@@ -400,6 +416,11 @@ def minimize_dr_vars(model_data, config):
 
     # === Solve the polishing model
     timer = TicTocTimer()
+    orig_setting, custom_setting_present = adjust_solver_time_settings(
+        model_data.timing,
+        solver,
+        config,
+    )
     timer.tic(msg=None)
     try:
         results = solver.solve(
@@ -420,6 +441,13 @@ def minimize_dr_vars(model_data, config):
             TIC_TOC_SOLVE_TIME_ATTR,
             timer.toc(msg=None),
         )
+    finally:
+        revert_solver_max_time_adjustment(
+            solver,
+            orig_setting,
+            custom_setting_present,
+            config,
+        )
 
     # === Process solution by termination condition
     acceptable = {
@@ -564,6 +592,11 @@ def solver_call_master(model_data, config, solver, solve_data):
 
     timer = TicTocTimer()
     for opt in backup_solvers:
+        orig_setting, custom_setting_present = adjust_solver_time_settings(
+            model_data.timing,
+            opt,
+            config,
+        )
         timer.tic(msg=None)
         try:
             results = opt.solve(
@@ -587,6 +620,13 @@ def solver_call_master(model_data, config, solver, solve_data):
                 TIC_TOC_SOLVE_TIME_ATTR,
                 timer.toc(msg=None),
             )
+        finally:
+            revert_solver_max_time_adjustment(
+                solver,
+                orig_setting,
+                custom_setting_present,
+                config,
+            )
 
         optimal_termination = check_optimal_termination(results)
         infeasible = results.solver.termination_condition == tc.infeasible
@@ -619,7 +659,6 @@ def solver_call_master(model_data, config, solver, solve_data):
                 v.value
                 for v in nlp_model.scenarios[0, 0].util.first_stage_variables
             )
-
             if config.objective_focus is ObjectiveType.nominal:
                 master_soln.ssv_vals = list(
                     v.value
@@ -647,6 +686,20 @@ def solver_call_master(model_data, config, solver, solve_data):
             master_soln.results = results
             master_soln.master_model = nlp_model
 
+        # if PyROS time limit exceeded, exit loop and return solution
+        elapsed = get_main_elapsed_time(model_data.timing)
+        if config.time_limit:
+            if elapsed >= config.time_limit:
+                try_backup = False
+                master_soln.master_subsolver_results = (
+                    None,
+                    pyrosTerminationCondition.time_out
+                )
+                master_soln.pyros_termination_condition = (
+                    pyrosTerminationCondition.time_out
+                )
+                output_logger(config=config, time_out=True, elapsed=elapsed)
+
         if not try_backup:
             return master_soln
 
@@ -691,6 +744,33 @@ def solve_master(model_data, config):
         results = solve_master_feasibility_problem(model_data, config)
         master_soln.feasibility_problem_results = results
 
+        # if pyros time limit reached, load time out status
+        # to master results and return to caller
+        elapsed = get_main_elapsed_time(model_data.timing)
+        if config.time_limit:
+            if elapsed >= config.time_limit:
+                # load master model
+                master_soln.master_model = model_data.master_model
+                master_soln.nominal_block = model_data.master_model.scenarios[0, 0]
+
+                # empty results object, with master solve time of zero
+                master_soln.results = SolverResults()
+                setattr(master_soln.results.solver, TIC_TOC_SOLVE_TIME_ATTR, 0)
+
+                # PyROS time out status
+                master_soln.pyros_termination_condition = (
+                    pyrosTerminationCondition.time_out
+                )
+                master_soln.master_subsolver_results = (
+                    None,
+                    pyrosTerminationCondition.time_out
+                )
+
+                # log time out message
+                output_logger(config=config, time_out=True, elapsed=elapsed)
+
+                return master_soln
+
     solver = config.global_solver if config.solve_master_globally else config.local_solver
 
     return solver_call_master(model_data=model_data, config=config, solver=solver,

pyomo/contrib/pyros/pyros.py

@@ -46,7 +46,7 @@
 from pyomo.core.base import Constraint
 
 
-__version__ = "1.2.5"
+__version__ = "1.2.6"
 
 
 def NonNegIntOrMinusOne(obj):
@@ -79,7 +79,7 @@ class SolverResolvable(object):
     def __call__(self, obj):
         '''
         if obj is a string, return the Solver object for that solver name
-        if obj is a Solver object, return the Solver
+        if obj is a Solver object, return a copy of the Solver
         if obj is a list, and each element of list is solver resolvable, return list of solvers
         '''
         if isinstance(obj, str):

pyomo/contrib/pyros/pyros_algorithm_methods.py

@@ -178,27 +178,25 @@ def ROSolver_iterative_solve(model_data, config):
             output_logger(config=config, robust_infeasible=True)
         elif master_soln.pyros_termination_condition is pyrosTerminationCondition.subsolver_error:
             term_cond = pyrosTerminationCondition.subsolver_error
+        elif master_soln.pyros_termination_condition is pyrosTerminationCondition.time_out:
+            term_cond = pyrosTerminationCondition.time_out
         else:
             term_cond = None
-        if term_cond == pyrosTerminationCondition.subsolver_error or \
-                term_cond == pyrosTerminationCondition.robust_infeasible:
-            update_grcs_solve_data(pyros_soln=model_data, k=k, term_cond=term_cond,
-                                   nominal_data=nominal_data,
-                                   timing_data=timing_data,
-                                   separation_data=separation_data,
-                                   master_soln=master_soln)
+        if term_cond in {
+                pyrosTerminationCondition.subsolver_error,
+                pyrosTerminationCondition.time_out,
+                pyrosTerminationCondition.robust_infeasible,
+                }:
+            update_grcs_solve_data(
+                pyros_soln=model_data,
+                k=k,
+                term_cond=term_cond,
+                nominal_data=nominal_data,
+                timing_data=timing_data,
+                separation_data=separation_data,
+                master_soln=master_soln,
+            )
             return model_data, []
-        # === Check if time limit reached
-        elapsed = get_main_elapsed_time(model_data.timing)
-        if config.time_limit:
-            if elapsed >= config.time_limit:
-                output_logger(config=config, time_out=True, elapsed=elapsed)
-                update_grcs_solve_data(pyros_soln=model_data, k=k, term_cond=pyrosTerminationCondition.time_out,
-                                       nominal_data=nominal_data,
-                                       timing_data=timing_data,
-                                       separation_data=separation_data,
-                                       master_soln=master_soln)
-                return model_data, []
 
         # === Save nominal information
         if k == 0:
@@ -212,7 +210,6 @@ def ROSolver_iterative_solve(model_data, config):
             nominal_data.nom_second_stage_cost = master_soln.second_stage_objective
             nominal_data.nom_obj = value(master_data.master_model.obj)
 
-
         if (
             # === Decision rule polishing (do not polish on first iteration if no ssv or if decision_rule_order = 0)
             (config.decision_rule_order != 0 and len(config.second_stage_variables) > 0 and k != 0)
@@ -234,6 +231,22 @@ def ROSolver_iterative_solve(model_data, config):
                     vals.append(dvar.value)
                 dr_var_lists_polished.append(vals)
 
+        # === Check if time limit reached
+        elapsed = get_main_elapsed_time(model_data.timing)
+        if config.time_limit:
+            if elapsed >= config.time_limit:
+                output_logger(config=config, time_out=True, elapsed=elapsed)
+                update_grcs_solve_data(
+                    pyros_soln=model_data,
+                    k=k,
+                    term_cond=pyrosTerminationCondition.time_out,
+                    nominal_data=nominal_data,
+                    timing_data=timing_data,
+                    separation_data=separation_data,
+                    master_soln=master_soln,
+                )
+                return model_data, []
+
         # === Set up for the separation problem
         separation_data.opt_fsv_vals = [v.value for v in master_soln.master_model.scenarios[0,0].util.first_stage_variables]
         separation_data.opt_ssv_vals = master_soln.ssv_vals
@@ -337,9 +350,3 @@ def ROSolver_iterative_solve(model_data, config):
 
     # === In this case we still return the final solution objects for the last iteration
     return model_data, separation_solns
-
-
-
-
-
-

pyomo/contrib/pyros/separation_problem_methods.py

@@ -21,7 +21,11 @@
 from pyomo.common.errors import ApplicationError
 from pyomo.contrib.pyros.util import ABS_CON_CHECK_FEAS_TOL
 from pyomo.common.timing import TicTocTimer
-from pyomo.contrib.pyros.util import TIC_TOC_SOLVE_TIME_ATTR
+from pyomo.contrib.pyros.util import (
+    TIC_TOC_SOLVE_TIME_ATTR,
+    adjust_solver_time_settings,
+    revert_solver_max_time_adjustment,
+)
 import os
 from copy import deepcopy
 
@@ -564,6 +568,11 @@ def solver_call_separation(model_data, config, solver, solve_data, is_global):
 
     timer = TicTocTimer()
     for opt in backup_solvers:
+        orig_setting, custom_setting_present = adjust_solver_time_settings(
+            model_data.timing,
+            opt,
+            config,
+        )
         timer.tic(msg=None)
         try:
             results = opt.solve(
@@ -587,6 +596,13 @@ def solver_call_separation(model_data, config, solver, solve_data, is_global):
                 TIC_TOC_SOLVE_TIME_ATTR,
                 timer.toc(msg=None),
             )
+        finally:
+            revert_solver_max_time_adjustment(
+                opt,
+                orig_setting,
+                custom_setting_present,
+                config,
+            )
 
         # record termination condition for this particular solver
         solver_status_dict[str(opt)] = results.solver.termination_condition