Merge branch 'pyros-sep-priorities-update' into pyros-multistage-2025

Author: shermanjasonaf

Diff for: pyomo/contrib/pyros/pyros_algorithm_methods.py

@@ -297,6 +297,15 @@ def ROSolver_iterative_solve(model_data):
         #     or in the event of bypassing global separation, no violations
         robustness_certified = separation_results.robustness_certified
         if robustness_certified:
+            if separation_data.ss_ineq_cons_to_bypass:
+                config.progress_logger.warning(
+                    "Separation of "
+                    f"{len(separation_data.ss_ineq_cons_to_bypass)} "
+                    "second-stage inequality constraints was bypassed "
+                    "due to user separation priority order specification. "
+                    "Thus, robust feasibility/optimality of the reported "
+                    "solution is not guaranteed."
+                )
             if config.bypass_global_separation:
                 config.progress_logger.warning(
                     "Option to bypass global separation was chosen. "

Diff for: pyomo/contrib/pyros/separation_problem_methods.py

@@ -36,6 +36,7 @@
 from pyomo.contrib.pyros.uncertainty_sets import Geometry
 from pyomo.contrib.pyros.util import (
     ABS_CON_CHECK_FEAS_TOL,
+    BYPASSING_SEPARATION_PRIORITY,
     call_solver,
     check_time_limit_reached,
 )
@@ -386,21 +387,50 @@ def group_ss_ineq_constraints_by_priority(separation_data):
         Keys are sorted in descending order
         (i.e. highest priority first).
     """
+    separation_data.config.progress_logger.debug(
+        "Grouping second-stage inequality constraints by separation priority..."
+    )
+
     ss_ineq_cons = separation_data.separation_model.second_stage.inequality_cons
     separation_priority_groups = dict()
     for name, ss_ineq_con in ss_ineq_cons.items():
-        # by default, priority set to 0
         priority = separation_data.separation_priority_order[name]
         cons_with_same_priority = separation_priority_groups.setdefault(priority, [])
         cons_with_same_priority.append(ss_ineq_con)
 
     # sort separation priority groups
-    return {
+    numeric_priority_grp_items = [
+        (priority, cons)
+        for priority, cons in separation_priority_groups.items()
+        if priority is not BYPASSING_SEPARATION_PRIORITY
+    ]
+    sorted_priority_groups = {
         priority: ss_ineq_cons
-        for priority, ss_ineq_cons in sorted(
-            separation_priority_groups.items(), reverse=True
-        )
+        for priority, ss_ineq_cons in sorted(numeric_priority_grp_items, reverse=True)
     }
+    if BYPASSING_SEPARATION_PRIORITY in separation_priority_groups:
+        sorted_priority_groups[BYPASSING_SEPARATION_PRIORITY] = (
+            separation_priority_groups[BYPASSING_SEPARATION_PRIORITY]
+        )
+
+    num_priority_groups = len(sorted_priority_groups)
+    separation_data.config.progress_logger.debug(
+        f"Found {num_priority_groups} separation "
+        f"priority group{'s' if num_priority_groups != 1 else ''}."
+    )
+    separation_data.config.progress_logger.debug(
+        "Separation priority grouping statistics:"
+    )
+    separation_data.config.progress_logger.debug(
+        f"  {'Priority':20s}{'# Ineq Cons':15s}"
+    )
+    for priority, cons in sorted_priority_groups.items():
+        priority_str = str(priority) + (" (bypass)" if priority is None else "")
+        separation_data.config.progress_logger.debug(
+            f"  {priority_str:20s}{len(cons):<15d}"
+        )
+
+    return sorted_priority_groups
 
 
 def get_worst_discrete_separation_solution(
@@ -566,7 +596,7 @@ def perform_separation_loop(separation_data, master_data, solve_globally):
         master_data=master_data,
         ss_ineq_cons=all_ss_ineq_constraints,
     )
-    sorted_priority_groups = group_ss_ineq_constraints_by_priority(separation_data)
+    sorted_priority_groups = separation_data.separation_priority_groups
     uncertainty_set_is_discrete = (
         config.uncertainty_set.geometry == Geometry.DISCRETE_SCENARIOS
     )
@@ -628,11 +658,24 @@ def perform_separation_loop(separation_data, master_data, solve_globally):
 
     all_solve_call_results = ComponentMap()
     priority_groups_enum = enumerate(sorted_priority_groups.items())
+    solve_desc = "global" if solve_globally else "local"
+    solve_adverb = "Globally" if solve_globally else "Locally"
     for group_idx, (priority, ss_ineq_constraints) in priority_groups_enum:
         priority_group_solve_call_results = ComponentMap()
+
+        if priority is BYPASSING_SEPARATION_PRIORITY:
+            config.progress_logger.debug(
+                f"Bypassing {solve_desc} separation of all "
+                f"{len(ss_ineq_constraints)} second-stage "
+                f"inequality constraints in the group with priority {priority} "
+                f"(group {group_idx + 1} of {len(sorted_priority_groups)}) "
+                f"as the priority value is {priority}."
+            )
+            worst_case_ss_ineq_con = None
+            continue
+
         for idx, ss_ineq_con in enumerate(ss_ineq_constraints):
             # log progress of separation loop
-            solve_adverb = "Globally" if solve_globally else "Locally"
             config.progress_logger.debug(
                 f"{solve_adverb} separating second-stage inequality constraint "
                 f"{get_con_name_repr(separation_data.separation_model, ss_ineq_con)} "
@@ -1293,6 +1336,12 @@ def __init__(self, model_data):
         else:
             self.idxs_of_master_scenarios = None
 
+        self.separation_priority_groups = group_ss_ineq_constraints_by_priority(self)
+
+    @property
+    def ss_ineq_cons_to_bypass(self):
+        return self.separation_priority_groups.get(BYPASSING_SEPARATION_PRIORITY, [])
+
     def solve_separation(self, master_data):
         """
         Solve the separation problem.