adding the child class evaluator and using it for batched objective evaluations in the BO loop

Author: thartland

src/hiopbbpy/opt/__init__.py

@@ -1,6 +1,7 @@
 from .boalgorithm import (BOAlgorithmBase, BOAlgorithm)
 from .acquisition import (acquisition, LCBacquisition, EIacquisition)
 from .optproblem import (IpoptProb)
+from .evaluator import Evaluator
 
 __all__ = [
         "BOAlgorithmBase"
@@ -9,4 +10,5 @@
         "LCBacquisition"
         "EIacquisition"
         "IpoptProb"
+        "Evaluator"
         ]

src/hiopbbpy/opt/boalgorithm.py

@@ -12,6 +12,7 @@
 import warnings
 from ..surrogate_modeling.gp import GaussianProcess
 from .acquisition import LCBacquisition, EIacquisition
+from .evaluator import Evaluator
 from ..problems.problem import Problem
 from .optproblem import IpoptProb
 
@@ -23,6 +24,7 @@ def __init__(self):
         self.xtrain = None            # Training data
         self.ytrain = None            # Training data
         self.prob   = None            # Problem structure
+        self.evaluator = None         # compute control objective evaluations
         self.bo_maxiter = 20          # Maximum number of Bayesian optimization steps
         self.n_start = 10             # estimating acquisition global optima by determining local optima n_start times and then determining the discrete max of that set
         self.batch_size = 1           # batch size
@@ -93,6 +95,9 @@ def __init__(self, prob:Problem, gpsurrogate:GaussianProcess, xtrain, ytrain,
                 f"batched BO only supported for expected-improvement"
         self.setAcquisitionType(acquisition_type, batch_size)
 
+        self.evaluator = options.get('evaluator', Evaluator())
+        assert isinstance(self.evaluator, Evaluator)
+
         if options and 'opt_solver' in options:
             opt_solver = options['opt_solver']
             assert opt_solver in ["SLSQP", "IPOPT"], f"Invalid opt_solver: {opt_solver}"
@@ -196,7 +201,8 @@ def optimize(self):
              y_train_virtual = np.vstack([y_train_virtual, y_virtual])
 
           # TODO: include a parallel evaluator
-          y_new = self.prob.evaluate(np.atleast_2d(x_train[-self.batch_size:]))
+          y_new = self.evaluator.run(self.prob.evaluate, x_train[-self.batch_size:])
+          #y_new = self.prob.evaluate(np.atleast_2d(x_train[-self.batch_size:]))
 
 
           y_train = np.vstack([y_train, y_new])

src/hiopbbpy/opt/evaluator.py

@@ -0,0 +1,32 @@
+"""
+Abstract evaluator to control how (batched) objective evaluations are performed 
+
+Authors:    Tucker Hartland <hartland1@llnl.gov>
+            Nai-Yuan Chiang <chiang7@llnl.gov>
+"""
+
+
+class Evaluator(object):
+    """
+    An interface for evaluation of a function at x points (nsamples of dimension nx).
+    User can derive this interface and override the run() method to implement custom multiprocessing.
+    """
+
+    def run(self, fun, x):
+        """
+        Evaluates fun at x.
+
+        Parameters
+        ---------
+        fun : function to evaluate: (nsamples, nx) -> (nsample, 1)
+
+        x : np.ndarray[nsamples, nx]
+            nsamples points of nx dimensions.
+
+        Returns
+        -------
+        np.ndarray[nsample, 1]
+            fun evaluations at the nsamples points.
+
+        """
+        return fun(x)