Solution Pool

pyomo/common/collections/bunch.py

@@ -16,6 +16,7 @@
 #  the U.S. Government retains certain rights in this software.
 #  ___________________________________________________________________________
 
+import types
 import shlex
 from collections.abc import Mapping
 
@@ -36,31 +37,38 @@ class Bunch(dict):
     def __init__(self, *args, **kw):
         self._name_ = self.__class__.__name__
         for arg in args:
-            if not isinstance(arg, str):
-                raise TypeError("Bunch() positional arguments must be strings")
-            for item in shlex.split(arg):
-                item = item.split('=', 1)
-                if len(item) != 2:
-                    raise ValueError(
-                        "Bunch() positional arguments must be space separated "
-                        f"strings of form 'key=value', got '{item[0]}'"
-                    )
-
-                # Historically, this used 'exec'.  That is unsafe in
-                # this context (because anyone can pass arguments to a
-                # Bunch).  While not strictly backwards compatible,
-                # Pyomo was not using this for anything past parsing
-                # None/float/int values.  We will explicitly parse those
-                # values
-                try:
-                    val = float(item[1])
-                    if int(val) == val:
-                        val = int(val)
-                    item[1] = val
-                except:
-                    if item[1].strip() == 'None':
-                        item[1] = None
-                self[item[0]] = item[1]
+            if isinstance(arg, types.GeneratorType):
+                for k, v in arg:
+                    self[k] = v
+            elif isinstance(arg, str):
+                for item in shlex.split(arg):
+                    item = item.split('=', 1)
+                    if len(item) != 2:
+                        raise ValueError(
+                            "Bunch() positional arguments must be space separated "
+                            f"strings of form 'key=value', got '{item[0]}'"
+                        )
+
+                    # Historically, this used 'exec'.  That is unsafe in
+                    # this context (because anyone can pass arguments to a
+                    # Bunch).  While not strictly backwards compatible,
+                    # Pyomo was not using this for anything past parsing
+                    # None/float/int values.  We will explicitly parse those
+                    # values
+                    try:
+                        val = float(item[1])
+                        if int(val) == val:
+                            val = int(val)
+                        item[1] = val
+                    except:
+                        if item[1].strip() == 'None':
+                            item[1] = None
+                    self[item[0]] = item[1]
+            else:
+                raise TypeError(
+                    "Bunch() positional arguments must either by generators returning tuples defining a dictionary, or "
+                    "space separated strings of form 'key=value'"
+                )
         for k, v in kw.items():
             self[k] = v
 

pyomo/common/tests/test_bunch.py

@@ -22,7 +22,7 @@
 
 
 class Test(unittest.TestCase):
-    def test_Bunch1(self):
+    def test_Bunch_fromString(self):
         opt = Bunch('a=None c=d e="1 2 3" f=" 5 "', foo=1, bar='x')
         self.assertEqual(opt.ll, None)
         self.assertEqual(opt.a, None)
@@ -85,7 +85,8 @@ def test_Bunch1(self):
         )
 
         with self.assertRaisesRegex(
-            TypeError, r"Bunch\(\) positional arguments must be strings"
+            TypeError,
+            r"Bunch\(\) positional arguments must either by generators returning tuples defining a dictionary, or space separated strings of form 'key=value'",
         ):
             Bunch(5)
 
@@ -96,6 +97,19 @@ def test_Bunch1(self):
         ):
             Bunch('a=5 foo = 6')
 
+    def test_Bunch_fromGenerator(self):
+        data = dict(a=None, c='d', e="1 2 3", f=" 5 ", foo=1, bar='x')
+        o1 = Bunch((k, v) for k, v in data.items())
+        self.assertEqual(
+            str(o1),
+            """a: None
+bar: 'x'
+c: 'd'
+e: '1 2 3'
+f: ' 5 '
+foo: 1""",
+        )
+
     def test_pickle(self):
         o1 = Bunch('a=None c=d e="1 2 3"', foo=1, bar='x')
         s = pickle.dumps(o1)

pyomo/contrib/alternative_solutions/__init__.py

@@ -10,11 +10,26 @@
 #  ___________________________________________________________________________
 
 from pyomo.contrib.alternative_solutions.aos_utils import logcontext
-from pyomo.contrib.alternative_solutions.solution import Solution
-from pyomo.contrib.alternative_solutions.solnpool import gurobi_generate_solutions
+from pyomo.contrib.alternative_solutions.solution import (
+    PyomoSolution,
+    Solution,
+    VariableInfo,
+    ObjectiveInfo,
+)
+from pyomo.contrib.alternative_solutions.solnpool import (
+    PoolManager,
+    PyomoPoolManager,
+    PoolPolicy,
+)
 from pyomo.contrib.alternative_solutions.balas import enumerate_binary_solutions
 from pyomo.contrib.alternative_solutions.obbt import (
     obbt_analysis,
     obbt_analysis_bounds_and_solutions,
 )
 from pyomo.contrib.alternative_solutions.lp_enum import enumerate_linear_solutions
+from pyomo.contrib.alternative_solutions.gurobi_lp_enum import (
+    gurobi_enumerate_linear_solutions,
+)
+from pyomo.contrib.alternative_solutions.gurobi_solnpool import (
+    gurobi_generate_solutions,
+)

pyomo/contrib/alternative_solutions/aos_utils.py

@@ -9,11 +9,12 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
+from pyomo.common.collections import Bunch as Munch
 import logging
+from contextlib import contextmanager
 
 logger = logging.getLogger(__name__)
 
-from contextlib import contextmanager
 
 from pyomo.common.dependencies import numpy as numpy, numpy_available
 
@@ -57,11 +58,10 @@ def get_active_objective(model):
     """
 
     active_objs = list(model.component_data_objects(pyo.Objective, active=True))
-    assert (
-        len(active_objs) == 1
-    ), "Model has {} active objective functions, exactly one is required.".format(
-        len(active_objs)
-    )
+    if len(active_objs) != 1:
+        raise RuntimeError(
+            f"Model has {len(active_objs)} active objective functions, exactly one is required."
+        )
 
     return active_objs[0]
 
@@ -81,12 +81,10 @@ def _add_objective_constraint(
     specified block.
     """
 
-    assert (
-        rel_opt_gap is None or rel_opt_gap >= 0.0
-    ), "rel_opt_gap must be None or >= 0.0"
-    assert (
-        abs_opt_gap is None or abs_opt_gap >= 0.0
-    ), "abs_opt_gap must be None or >= 0.0"
+    if not (rel_opt_gap is None or rel_opt_gap >= 0.0):
+        raise ValueError(f"rel_opt_gap ({rel_opt_gap}) must be None or >= 0.0")
+    if not (abs_opt_gap is None or abs_opt_gap >= 0.0):
+        raise ValueError(f"abs_opt_gap ({abs_opt_gap}) must be None or >= 0.0")
 
     objective_constraints = []
 
@@ -302,3 +300,21 @@ def get_model_variables(
                 )
 
     return variable_set
+
+
+class MyMunch(Munch):
+    # WEH, MPV needed to add a to_dict since Bunch did not have one
+    def to_dict(self):
+        return to_dict(self)
+
+
+def to_dict(x):
+    xtype = type(x)
+    if xtype in [tuple, set, frozenset]:
+        return list(x)
+    elif xtype in [dict, Munch, MyMunch]:
+        return {k: to_dict(v) for k, v in x.items()}
+    elif hasattr(x, "to_dict"):
+        return x.to_dict()
+    else:
+        return x

pyomo/contrib/alternative_solutions/balas.py

@@ -15,7 +15,7 @@
 
 import pyomo.environ as pyo
 from pyomo.common.collections import ComponentSet
-from pyomo.contrib.alternative_solutions import Solution
+from pyomo.contrib.alternative_solutions import PyomoPoolManager, PoolPolicy
 import pyomo.contrib.alternative_solutions.aos_utils as aos_utils
 
 
@@ -31,6 +31,7 @@ def enumerate_binary_solutions(
     solver_options={},
     tee=False,
     seed=None,
+    pool_manager=None,
 ):
     """
     Finds alternative optimal solutions for a binary problem using no-good
@@ -44,7 +45,7 @@ def enumerate_binary_solutions(
     model : ConcreteModel
         A concrete Pyomo model
     num_solutions : int
-        The maximum number of solutions to generate.
+        The maximum number of solutions to generate. Must be positive
     variables: None or a collection of Pyomo _GeneralVarData variables
         The variables for which bounds will be generated. None indicates
         that all variables will be included. Alternatively, a collection of
@@ -71,25 +72,34 @@ def enumerate_binary_solutions(
         Boolean indicating that the solver output should be displayed.
     seed : int
         Optional integer seed for the numpy random number generator
+    pool_manager : None
+        Optional pool manager that will be used to collect solutions
 
     Returns
     -------
-    solutions
-        A list of Solution objects.
-        [Solution]
+    pool_manager
+        A PyomoPoolManager object
 
     """
     logger.info("STARTING NO-GOOD CUT ANALYSIS")
 
-    assert search_mode in [
-        "optimal",
-        "random",
-        "hamming",
-    ], 'search mode must be "optimal", "random", or "hamming".'
+    if not (num_solutions >= 1):
+        raise RuntimeError("num_solutions must be positive integer")
+    if num_solutions == 1:
+        logger.warning("Running alternative_solutions method to find only 1 solution!")
+
+    if not (search_mode in ["optimal", "random", "hamming"]):
+        raise ValueError('search mode must be "optimal", "random", or "hamming".')
 
     if seed is not None:
         aos_utils._set_numpy_rng(seed)
 
+    if pool_manager is None:
+        pool_manager = PyomoPoolManager()
+        pool_manager.add_pool(
+            name="enumerate_binary_solutions", policy=PoolPolicy.keep_all
+        )
+
     all_variables = aos_utils.get_model_variables(model, include_fixed=True)
     if variables == None:
         binary_variables = [
@@ -108,18 +118,18 @@ def enumerate_binary_solutions(
             else:  # pragma: no cover
                 non_binary_variables.append(var.name)
         if len(non_binary_variables) > 0:
-            logger.warn(
+            logger.warning(
                 (
                     "Warning: The following non-binary variables were included"
                     "in the variable list and will be ignored:"
                 )
             )
-            logger.warn(", ".join(non_binary_variables))
+            logger.warning(", ".join(non_binary_variables))
 
     orig_objective = aos_utils.get_active_objective(model)
 
     if len(binary_variables) == 0:
-        logger.warn("No binary variables found!")
+        logger.warning("No binary variables found!")
 
     #
     # Setup solver
@@ -152,7 +162,6 @@ def enumerate_binary_solutions(
         else:
             opt.update_config.check_for_new_objective = False
             opt.update_config.update_objective = False
-
     #
     # Initial solve of the model
     #
@@ -172,12 +181,12 @@ def enumerate_binary_solutions(
     model.solutions.load_from(results)
     orig_objective_value = pyo.value(orig_objective)
     logger.info("Found optimal solution, value = {}.".format(orig_objective_value))
-    solutions = [Solution(model, all_variables, objective=orig_objective)]
+    pool_manager.add(variables=all_variables, objective=orig_objective)
     #
     # Return just this solution if there are no binary variables
     #
     if len(binary_variables) == 0:
-        return solutions
+        return pool_manager
 
     aos_block = aos_utils._add_aos_block(model, name="_balas")
     logger.info("Added block {} to the model.".format(aos_block))
@@ -231,7 +240,7 @@ def enumerate_binary_solutions(
             logger.info(
                 "Iteration {}: objective = {}".format(solution_number, orig_obj_value)
             )
-            solutions.append(Solution(model, all_variables, objective=orig_objective))
+            pool_manager.add(variables=all_variables, objective=orig_objective)
             solution_number += 1
         elif (
             condition == pyo.TerminationCondition.infeasibleOrUnbounded
@@ -257,4 +266,4 @@ def enumerate_binary_solutions(
 
     logger.info("COMPLETED NO-GOOD CUT ANALYSIS")
 
-    return solutions
+    return pool_manager