test CI

Author: nychiang

.github/push_mirror.yml .github/push_mirror.Nyml.github/push_mirror.yml renamed to .github/push_mirror.Nyml

@@ -0,0 +1,32 @@
+name: test_hiopbbpy
+
+on: [push]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4  # Set up Python environment
+        with:
+          python-version: '3.13'
+
+
+      - name: Install HiOpBBPy and its dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .
+
+      - name: Run Tests
+        run: |
+          python src/Drivers/hiopbbpy/BODriver.py
+        continue-on-error: false
+          
+

.github/workflows/spack_build.yml .github/workflows/spack_build.Nyml.github/workflows/spack_build.yml renamed to .github/workflows/spack_build.Nyml

@@ -7,6 +7,7 @@
         3) determine the minimizer via BOAlgorithm
 """
 
+import sys
 import numpy as np
 import matplotlib.pyplot as plt
 import warnings
@@ -17,34 +18,75 @@
 from hiopbbpy.problems import BraninProblem
 
 
-### parameters
-n_samples = 5 # number of the initial samples to train GP
-theta = 1.e-2 # hyperparameter for GP kernel
+# Get user input for the number of repetitions from command-line arguments
+if len(sys.argv) != 2:
+    num_repeat = 1
+else:
+    num_repeat = int(sys.argv[1])
 
-nx = 2 # dimension of the problem
+### parameters
+n_samples = 5  # number of the initial samples to train GP
+theta = 1.e-2  # hyperparameter for GP kernel
+nx = 2         # dimension of the problem
 xlimits = np.array([[-5, 5], [-5, 5]]) # bounds on optimization variable
 
-#problem = LpNormProblem(nx, xlimits)
-problem = BraninProblem()
-
-print(problem.name, " problem")
-
-### initial training set
-x_train = problem.sample(n_samples)
-y_train = problem.evaluate(x_train)
-
-# Define the GP surrogate model
-gp_model = smtKRG(theta, xlimits, nx)
-gp_model.train(x_train, y_train)
-
-acquisition_types = ["LCB", "EI"]
-for acquisition_type in acquisition_types:
-    print("acquisition type: ", acquisition_type)
-    
-    # Instantiate and run Bayesian Optimization
-    bo = BOAlgorithm(gp_model, x_train, y_train, acquisition_type = acquisition_type) #EI or LCB
-    bo.optimize(problem)
-    
-    # Retrieve optimal point
-    x_opt, y_opt = bo.getOptimalPoint()
-    print()
+### saved solutions
+saved_sol = {"LpNorm": {"LCB": 0.04618462, "EI": 0.44954611}, "Branin": {"LCB": 0.62655919, "EI": 1.9838798}}
+
+prob_type_l = ["LpNorm", "Branin"]
+acq_type_l = ["LCB", "EI"]
+
+mean_obj = {}
+
+retval = 0
+for prob_type in prob_type_l:
+   print()
+   if prob_type == "LpNorm":
+      problem = LpNormProblem(nx, xlimits)
+   else:
+      problem = BraninProblem()
+
+   if prob_type not in mean_obj:
+      mean_obj[prob_type] = {}
+
+   for acq_type in acq_type_l:
+      if acq_type not in mean_obj[prob_type]:
+         mean_obj[prob_type][acq_type] = 0
+
+      print("Problem name: ", problem.name)
+      print("Acquisition type: ", acq_type)
+   
+      for n_repeat in range(num_repeat):
+         print("Run: ", n_repeat, "/", num_repeat)
+         ### initial training set
+         x_train = problem.sample(n_samples)
+         y_train = problem.evaluate(x_train)
+
+         ### Define the GP surrogate model
+         gp_model = smtKRG(theta, xlimits, nx)
+         gp_model.train(x_train, y_train)
+   
+         # Instantiate and run Bayesian Optimization
+         bo = BOAlgorithm(gp_model, x_train, y_train, acquisition_type = acq_type) #EI or LCB
+         bo.optimize(problem)
+         
+         # Retrieve optimal objec
+         y_opt = bo.getOptimalObjective()
+         
+         mean_obj[prob_type][acq_type] += y_opt
+
+for prob_type in prob_type_l:
+   for acq_type in acq_type_l:
+      mean_obj[prob_type][acq_type] /= num_repeat
+      print("Mean Opt.Obj for ", prob_type, "-", acq_type, mean_obj[prob_type][acq_type])
+      
+      r_error = np.abs((mean_obj[prob_type][acq_type] - saved_sol[prob_type][acq_type])/saved_sol[prob_type][acq_type])
+      if r_error > 0.5:
+         print("Relative Error > 0.5: ", r_error)
+         print("Recorded Solution:", saved_sol[prob_type][acq_type])
+         retval = 1
+
+sys.exit(retval)
+
+
+

.github/workflows/test.yml .github/workflows/test.Nyml.github/workflows/test.yml renamed to .github/workflows/test.Nyml

@@ -8,6 +8,7 @@
 import numpy as np
 from numpy.random import uniform
 from scipy.optimize import minimize
+from scipy.stats import qmc
 from ..surrogate_modeling.gp import GaussianProcess
 from .acquisition import LCBacquisition, EIacquisition
 from ..problems.problem import Problem
@@ -18,6 +19,7 @@ def __init__(self):
         self.acquisition_type = "LCB" # Type of acquisition function (default = "LCB")
         self.xtrain = None            # Training data
         self.ytrain = None            # Training data
+        self.prob   = None            # Problem structure
         self.n_iter = 20              # Maximum number of 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.q = 1                    # batch size
@@ -48,11 +50,15 @@ def getOptimizationHistory(self):
         y_hist = np.array(self.y_hist, copy=True)
         return x_hist, y_hist
 
-    # Method to return the optimal solution and objective
+    # Method to return the optimal solution 
     def getOptimalPoint(self):
         x_opt = np.array(self.x_opt, copy=True)
+        return x_opt
+
+    # Method to return the optimal objective
+    def getOptimalObjective(self):
         y_opt = np.array(self.y_opt, copy=True)
-        return x_opt, y_opt
+        return y_opt
 
 # A subclass of BOAlgorithmBase implementing a full Bayesian Optimization workflow
 class BOAlgorithm(BOAlgorithmBase):
@@ -96,8 +102,11 @@ def _find_best_point(self, x_train, y_train, x0 = None):
         for ii in range(self.n_start):
             success = False
             # Generate random starting point if x0 is not provided
-            if x0 is None:
+            if x0 is None and self.prob is not None:
+                x0 = self.prob.sample(1)
+            else:
                 x0 = np.array([uniform(b[0], b[1]) for b in self.bounds])
+                
             xopt, yout, success = self.acqf_minimizer_callback(acqf_callback, x0)
 
             if success:
@@ -118,6 +127,7 @@ def set_options(self, options):
 
     # Method to perform Bayesian optimization
     def optimize(self, prob:Problem):
+      self.problem = prob
       x_train = self.xtrain
       y_train = self.ytrain
 
@@ -162,6 +172,8 @@ def optimize(self, prob:Problem):
           print(f"Optimal at BO iteration: {self.idx_opt-n_init_sample+1} ")
 
       print(f"Optimal point: {self.x_opt.flatten()}, Optimal value: {self.y_opt}")
+      print()
+
 
 
 # Find the minimum of the input objective `fun`, using the minimize function from SciPy.