Nonant bounds buffer

mpisppy/cylinders/fwph_spoke.py

@@ -27,6 +27,9 @@ def sync(self):
         # Tell the hub about the most recent bound
         self.send_bound(self.opt._local_bound)
 
+        # Update the nonant bounds, if possible
+        self.receive_nonant_bounds()
+
     def finalize(self):
         # The FWPH spoke can call "finalize" before it
         # even starts doing anything, so its possible

mpisppy/cylinders/hub.py

@@ -12,22 +12,21 @@
 import mpisppy.log
 
 from mpisppy.cylinders.spcommunicator import RecvArray, SPCommunicator
-from math import inf
 
 from mpisppy import global_toc
 
 from mpisppy.cylinders.spwindow import Field
 
 # Could also pass, e.g., sys.stdout instead of a filename
-mpisppy.log.setup_logger("mpisppy.cylinders.Hub",
+mpisppy.log.setup_logger(__name__,
                          "hub.log",
                          level=logging.CRITICAL)
-logger = logging.getLogger("mpisppy.cylinders.Hub")
+logger = logging.getLogger(__name__)
 
 class Hub(SPCommunicator):
 
     send_fields = (*SPCommunicator.send_fields, Field.SHUTDOWN, Field.BEST_OBJECTIVE_BOUNDS,)
-    receive_fields = (*SPCommunicator.receive_fields, Field.OBJECTIVE_INNER_BOUND, Field.OBJECTIVE_OUTER_BOUND, )
+    receive_fields = (*SPCommunicator.receive_fields,)
 
     _hub_algo_best_bound_provider = False
 
@@ -37,16 +36,10 @@ def __init__(self, spbase_object, fullcomm, strata_comm, cylinder_comm, communic
         logger.debug(f"Built the hub object on global rank {fullcomm.Get_rank()}")
         # for logging
         self.print_init = True
-        self.latest_ib_char = None
-        self.latest_ob_char = None
-        self.last_ib_idx = None
-        self.last_ob_idx = None
         # for termination based on stalling out
         self.stalled_iter_cnt = 0
         self.last_gap = float('inf')  # abs_gap tracker
 
-        self.initialize_bound_values()
-
         return
 
     @abc.abstractmethod
@@ -175,72 +168,6 @@ def hub_finalize(self):
             global_toc("Statistics at termination", True)
             self.screen_trace()
 
-    def receive_innerbounds(self):
-        """ Get inner bounds from inner bound spokes
-            NOTE: Does not check if there _are_ innerbound spokes
-            (but should be harmless to call if there are none)
-        """
-        logging.debug("Hub is trying to receive from InnerBounds")
-        for idx, cls, recv_buf in self.receive_field_spcomms[Field.OBJECTIVE_INNER_BOUND]:
-            is_new = self.get_receive_buffer(recv_buf, Field.OBJECTIVE_INNER_BOUND, idx)
-            if is_new:
-                bound = recv_buf[0]
-                logging.debug("!! new InnerBound to opt {}".format(bound))
-                self.BestInnerBound = self.InnerBoundUpdate(bound, cls, idx)
-        logging.debug("ph back from InnerBounds")
-
-    def receive_outerbounds(self):
-        """ Get outer bounds from outer bound spokes
-            NOTE: Does not check if there _are_ outerbound spokes
-            (but should be harmless to call if there are none)
-        """
-        logging.debug("Hub is trying to receive from OuterBounds")
-        for idx, cls, recv_buf in self.receive_field_spcomms[Field.OBJECTIVE_OUTER_BOUND]:
-            is_new = self.get_receive_buffer(recv_buf, Field.OBJECTIVE_OUTER_BOUND, idx)
-            if is_new:
-                bound = recv_buf[0]
-                logging.debug("!! new OuterBound to opt {}".format(bound))
-                self.BestOuterBound = self.OuterBoundUpdate(bound, cls, idx)
-        logging.debug("ph back from OuterBounds")
-
-    def OuterBoundUpdate(self, new_bound, cls=None, idx=None, char='*'):
-        current_bound = self.BestOuterBound
-        if self._outer_bound_update(new_bound, current_bound):
-            if cls is None:
-                self.latest_ob_char = char
-                self.last_ob_idx = 0
-            else:
-                self.latest_ob_char = cls.converger_spoke_char
-                self.last_ob_idx = idx
-            return new_bound
-        else:
-            return current_bound
-
-    def InnerBoundUpdate(self, new_bound, cls=None, idx=None, char='*'):
-        current_bound = self.BestInnerBound
-        if self._inner_bound_update(new_bound, current_bound):
-            if cls is None:
-                self.latest_ib_char = char
-                self.last_ib_idx = 0
-            else:
-                self.latest_ib_char = cls.converger_spoke_char
-                self.last_ib_idx = idx
-            return new_bound
-        else:
-            return current_bound
-
-    def initialize_bound_values(self):
-        if self.opt.is_minimizing:
-            self.BestInnerBound = inf
-            self.BestOuterBound = -inf
-            self._inner_bound_update = lambda new, old : (new < old)
-            self._outer_bound_update = lambda new, old : (new > old)
-        else:
-            self.BestInnerBound = -inf
-            self.BestOuterBound = inf
-            self._inner_bound_update = lambda new, old : (new > old)
-            self._outer_bound_update = lambda new, old : (new < old)
-
     def _populate_boundsout_cache(self, buf):
         """ Populate a given buffer with the current bounds
         """
@@ -292,6 +219,7 @@ def send_terminate(self):
         return
 
     def sync_bounds(self):
+        self.receive_nonant_bounds()
         self.receive_outerbounds()
         self.receive_innerbounds()
         self.send_boundsout()

mpisppy/cylinders/lagrangian_bounder.py

@@ -19,6 +19,8 @@ def lagrangian_prep(self):
         self.opt._create_solvers()
 
     def lagrangian(self, need_solution=True):
+        # update the nonant bounds, if possible, for a tighter relaxation
+        self.receive_nonant_bounds()
         verbose = self.opt.options['verbose']
         # This is sort of a hack, but might help folks:
         if "ipopt" in self.opt.options["solver_name"]:
@@ -54,12 +56,21 @@ class LagrangianOuterBound(_LagrangianMixin, mpisppy.cylinders.spoke.OuterBoundW
 
     converger_spoke_char = 'L'
 
-    def _set_weights_and_solve(self, need_solution=True):
+    def _set_weights_and_solve(self, need_solution):
         self.opt.W_from_flat_list(self.localWs) # Sets the weights
         return self.lagrangian(need_solution=need_solution)
 
+    def do_while_waiting_for_new_Ws(self, need_solution):
+        if self.opt.options.get("subgradient_while_waiting", False):
+            # compute a subgradient step
+            self.opt.Compute_Xbar(self.verbose)
+            self.opt.Update_W(self.verbose)
+            bound = self.lagrangian(need_solution=need_solution)
+            if bound is not None:
+                self.send_bound(bound)
+
     def main(self, need_solution=False):
-        verbose = self.opt.options['verbose']
+        self.verbose = self.opt.options['verbose']
         extensions = self.opt.extensions is not None
 
         self.lagrangian_prep()
@@ -89,10 +100,5 @@ def main(self, need_solution=False):
                 if extensions:
                     self.opt.extobject.enditer_after_sync()
                 self.dk_iter += 1
-            elif self.opt.options.get("subgradient_while_waiting", False):
-                # compute a subgradient step
-                self.opt.Compute_Xbar(verbose)
-                self.opt.Update_W(verbose)
-                bound = self.lagrangian(need_solution=need_solution)
-                if bound is not None:
-                    self.send_bound(bound)
+            else:
+                self.do_while_waiting_for_new_Ws(need_solution=need_solution)