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
 
@@ -162,3 +170,6 @@ def __str__(self, nesting=0, indent=''):
             attrs.append("".join(text))
         attrs.sort()
         return "\n".join(attrs)
+
+    def toDict(self):
+        return self

pyomo/common/tests/test_bunch.py

@@ -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_Bunch2(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,22 @@
 #  ___________________________________________________________________________
 
 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
 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
 
@@ -302,3 +303,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 [float, int, complex, str, list, bool] or x is None:
+        return x
+    elif 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()}
+    else:
+        return x.to_dict()

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
 import pyomo.contrib.alternative_solutions.aos_utils as aos_utils
 
 
@@ -31,6 +31,7 @@ def enumerate_binary_solutions(
     solver_options={},
     tee=False,
     seed=None,
+    poolmanager=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,16 +72,21 @@ def enumerate_binary_solutions(
         Boolean indicating that the solver output should be displayed.
     seed : int
         Optional integer seed for the numpy random number generator
+    poolmanager : None
+        Optional pool manager that will be used to collect solution
 
     Returns
     -------
-    solutions
-        A list of Solution objects.
-        [Solution]
+    poolmanager
+        A PyomoPoolManager object
 
     """
     logger.info("STARTING NO-GOOD CUT ANALYSIS")
 
+    assert num_solutions >= 1, "num_solutions must be positive integer"
+    if num_solutions == 1:
+        logger.warning("Running alternative_solutions method to find only 1 solution!")
+
     assert search_mode in [
         "optimal",
         "random",
@@ -90,6 +96,10 @@ def enumerate_binary_solutions(
     if seed is not None:
         aos_utils._set_numpy_rng(seed)
 
+    if poolmanager is None:
+        poolmanager = PyomoPoolManager()
+        poolmanager.add_pool(name="enumerate_binary_solutions", policy="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)]
+    poolmanager.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 poolmanager
 
     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))
+            poolmanager.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 poolmanager