PyROS Add caching for computed uncertain parameter bounds

pyomo/contrib/pyros/CHANGELOG.txt

@@ -3,6 +3,12 @@ PyROS CHANGELOG
 ===============
 
 
+-------------------------------------------------------------------------------
+PyROS 1.3.14    20 Mar 2026
+-------------------------------------------------------------------------------
+- Add caching for uncertainty set parameter bounds
+
+
 -------------------------------------------------------------------------------
 PyROS 1.3.13    16 Jan 2026
 -------------------------------------------------------------------------------

pyomo/contrib/pyros/pyros.py

@@ -418,83 +418,97 @@ def solve(
             self._log_intro(logger=progress_logger, level=logging.INFO)
             self._log_disclaimer(logger=progress_logger, level=logging.INFO)
 
-            config, user_var_partitioning = self._resolve_and_validate_pyros_args(
-                model, **kwds
-            )
-            self._log_config_user_values(
-                logger=config.progress_logger,
-                config=config,
-                exclude_options=(
-                    self._DEFAULT_CONFIG_USER_OPTIONS
-                    + ["nominal_uncertain_param_vals"]
-                    * (not nominal_param_vals_in_kwds)
-                ),
-                level=logging.INFO,
-            )
-            self._log_config(
-                logger=config.progress_logger,
-                config=config,
-                exclude_options=None,
-                level=logging.DEBUG,
-            )
-            model_data.config = config
-
-            log_original_model_statistics(model_data, user_var_partitioning)
-            IterationLogRecord.log_header_rule(config.progress_logger.info)
-            config.progress_logger.info("Preprocessing...")
-            model_data.timing.start_timer("main.preprocessing")
-            robust_infeasible = model_data.preprocess(user_var_partitioning)
-            model_data.timing.stop_timer("main.preprocessing")
-            preprocessing_time = model_data.timing.get_total_time("main.preprocessing")
-            config.progress_logger.info(
-                f"Done preprocessing; required wall time of "
-                f"{preprocessing_time:.3f}s."
-            )
-
-            IterationLogRecord.log_header_rule(config.progress_logger.debug)
-            log_preprocessed_model_statistics(model_data)
+            # clear cache before validation
+            if hasattr(uncertainty_set, "_cache"):
+                uncertainty_set._cache.clear()
+
+            # try solving and clear any cached values to free memory
+            try:
+                config, user_var_partitioning = self._resolve_and_validate_pyros_args(
+                    model, **kwds
+                )
+                self._log_config_user_values(
+                    logger=config.progress_logger,
+                    config=config,
+                    exclude_options=(
+                        self._DEFAULT_CONFIG_USER_OPTIONS
+                        + ["nominal_uncertain_param_vals"]
+                        * (not nominal_param_vals_in_kwds)
+                    ),
+                    level=logging.INFO,
+                )
+                self._log_config(
+                    logger=config.progress_logger,
+                    config=config,
+                    exclude_options=None,
+                    level=logging.DEBUG,
+                )
+                model_data.config = config
 
-            # === Solve and load solution into model
-            return_soln = ROSolveResults()
-            if not robust_infeasible:
-                pyros_soln = ROSolver_iterative_solve(model_data)
+                log_original_model_statistics(model_data, user_var_partitioning)
                 IterationLogRecord.log_header_rule(config.progress_logger.info)
+                config.progress_logger.info("Preprocessing...")
+                model_data.timing.start_timer("main.preprocessing")
+                robust_infeasible = model_data.preprocess(user_var_partitioning)
+                model_data.timing.stop_timer("main.preprocessing")
+                preprocessing_time = model_data.timing.get_total_time(
+                    "main.preprocessing"
+                )
+                config.progress_logger.info(
+                    f"Done preprocessing; required wall time of "
+                    f"{preprocessing_time:.3f}s."
+                )
 
-                termination_acceptable = pyros_soln.pyros_termination_condition in {
-                    pyrosTerminationCondition.robust_optimal,
-                    pyrosTerminationCondition.robust_feasible,
-                }
-                if termination_acceptable:
-                    load_final_solution(
-                        model_data=model_data,
-                        master_soln=pyros_soln.master_results,
-                        original_user_var_partitioning=user_var_partitioning,
+                IterationLogRecord.log_header_rule(config.progress_logger.debug)
+                log_preprocessed_model_statistics(model_data)
+
+                # === Solve and load solution into model
+                return_soln = ROSolveResults()
+                if not robust_infeasible:
+                    pyros_soln = ROSolver_iterative_solve(model_data)
+                    IterationLogRecord.log_header_rule(config.progress_logger.info)
+
+                    termination_acceptable = pyros_soln.pyros_termination_condition in {
+                        pyrosTerminationCondition.robust_optimal,
+                        pyrosTerminationCondition.robust_feasible,
+                    }
+                    if termination_acceptable:
+                        load_final_solution(
+                            model_data=model_data,
+                            master_soln=pyros_soln.master_results,
+                            original_user_var_partitioning=user_var_partitioning,
+                        )
+
+                    # get the most recent master objective, if available
+                    return_soln.final_objective_value = None
+                    master_epigraph_obj_value = value(
+                        pyros_soln.master_results.master_model.epigraph_obj,
+                        exception=False,
                     )
-
-                # get the most recent master objective, if available
-                return_soln.final_objective_value = None
-                master_epigraph_obj_value = value(
-                    pyros_soln.master_results.master_model.epigraph_obj, exception=False
-                )
-                if master_epigraph_obj_value is not None:
-                    # account for sense of the original model objective
-                    # when reporting the final PyROS (master) objective,
-                    # since maximization objective is changed to
-                    # minimization objective during preprocessing
-                    return_soln.final_objective_value = (
-                        model_data.active_obj_original_sense * master_epigraph_obj_value
+                    if master_epigraph_obj_value is not None:
+                        # account for sense of the original model objective
+                        # when reporting the final PyROS (master) objective,
+                        # since maximization objective is changed to
+                        # minimization objective during preprocessing
+                        return_soln.final_objective_value = (
+                            model_data.active_obj_original_sense
+                            * master_epigraph_obj_value
+                        )
+
+                    return_soln.pyros_termination_condition = (
+                        pyros_soln.pyros_termination_condition
+                    )
+                    return_soln.iterations = pyros_soln.iterations
+                else:
+                    return_soln.final_objective_value = None
+                    return_soln.pyros_termination_condition = (
+                        pyrosTerminationCondition.robust_infeasible
                     )
+                    return_soln.iterations = 0
 
-                return_soln.pyros_termination_condition = (
-                    pyros_soln.pyros_termination_condition
-                )
-                return_soln.iterations = pyros_soln.iterations
-            else:
-                return_soln.final_objective_value = None
-                return_soln.pyros_termination_condition = (
-                    pyrosTerminationCondition.robust_infeasible
-                )
-                return_soln.iterations = 0
+            finally:
+                if hasattr(uncertainty_set, "_cache"):
+                    uncertainty_set._cache.clear()
 
         return_soln.config = config
         return_soln.time = model_data.timing.get_total_time("main")