moospread 0.1.0__py3-none-any.whl

moospread/utils/mobo_utils/mobo/mobo.py

@@ -0,0 +1,132 @@
+import numpy as np
+from moospread.utils.mobo_utils.mobo.surrogate_problem import SurrogateProblem
+from moospread.utils.mobo_utils.mobo.utils import Timer, find_pareto_front, calc_hypervolume
+from moospread.utils.mobo_utils.mobo.factory import init_from_config
+from moospread.utils.mobo_utils.mobo.transformation import StandardTransform
+
+'''
+Main algorithm framework for Multi-Objective Bayesian Optimization
+'''
+
+class MOBO:
+    '''
+    Base class of algorithm framework, inherit this class with different configs to create new algorithm classes
+    '''
+    config = {}
+
+    def __init__(self, problem, n_iter, ref_point, framework_args):
+        '''
+        Input:
+            problem: the original / real optimization problem
+            n_iter: number of iterations to optimize
+            ref_point: reference point for hypervolume calculation
+            framework_args: arguments to initialize each component of the framework
+        '''
+        self.real_problem = problem
+        self.n_var, self.n_obj = problem.n_var, problem.n_obj
+        self.n_iter = n_iter
+        self.ref_point = ref_point
+
+        bounds = np.array([problem.xl, problem.xu])
+        self.transformation = StandardTransform(bounds) # data normalization for surrogate model fitting
+
+        # framework components
+        framework_args['surrogate']['n_var'] = self.n_var # for surrogate fitting
+        framework_args['surrogate']['n_obj'] = self.n_obj # for surroagte fitting
+        framework_args['solver']['n_obj'] = self.n_obj # for MOEA/D-EGO
+        framework = init_from_config(self.config, framework_args)
+        
+        self.surrogate_model = framework['surrogate'] # surrogate model
+        self.acquisition = framework['acquisition'] # acquisition function
+        self.solver = framework['solver'] # multi-objective solver for finding the paretofront
+        self.selection = framework['selection'] # selection method for choosing new (batch of) samples to evaluate on real problem
+        
+        # to keep track of data and pareto information (current status of algorithm)
+        self.X = None
+        self.Y = None
+        self.sample_num = 0
+        self.status = {
+            'pset': None,
+            'pfront': None,
+            'hv': None,
+            'ref_point': self.ref_point,
+        }
+
+        # other component-specific information that needs to be stored or exported
+        self.info = None
+
+    def _update_status(self, X, Y):
+        '''
+        Update the status of algorithm from data
+        '''
+        if self.sample_num == 0:
+            self.X = X
+            self.Y = Y
+        else:
+            self.X = np.vstack([self.X, X])
+            self.Y = np.vstack([self.Y, Y])
+        self.sample_num += len(X)
+
+        self.status['pfront'], pfront_idx = find_pareto_front(self.Y, return_index=True)
+        self.status['pset'] = self.X[pfront_idx]
+        self.status['hv'] = calc_hypervolume(self.status['pfront'], self.ref_point)
+
+    def solve(self, X_init, Y_init):
+        '''
+        Solve the real multi-objective problem from initial data (X_init, Y_init)
+        '''
+        # determine reference point from data if not specified by arguments
+        if self.ref_point is None:
+            self.ref_point = np.max(Y_init, axis=0)
+        self.selection.set_ref_point(self.ref_point)
+
+        self._update_status(X_init, Y_init)
+
+        global_timer = Timer()
+
+        for i in range(self.n_iter):
+            print('========== Iteration %d ==========' % i)
+
+            timer = Timer()
+
+            # data normalization
+            self.transformation.fit(self.X, self.Y)
+            X, Y = self.transformation.do(self.X, self.Y)
+
+            # build surrogate models
+            self.surrogate_model.fit(X, Y)
+            timer.log('Surrogate model fitted')
+
+            # define acquisition functions
+            self.acquisition.fit(X, Y)
+
+            # solve surrogate problem
+            surr_problem = SurrogateProblem(self.real_problem, self.surrogate_model, self.acquisition, self.transformation)
+            solution = self.solver.solve(surr_problem, X, Y)
+            timer.log('Surrogate problem solved')
+
+            # batch point selection
+            self.selection.fit(X, Y)
+            X_next, self.info = self.selection.select(solution, self.surrogate_model, self.status, self.transformation)
+            timer.log('Next sample batch selected')
+
+            # update dataset
+            Y_next = self.real_problem.evaluate(X_next)
+            self._update_status(X_next, Y_next)
+            timer.log('New samples evaluated')
+
+            # statistics
+            global_timer.log('Total runtime', reset=False)
+            print('Total evaluations: %d, hypervolume: %.4f\n' % (self.sample_num, self.status['hv']))
+            
+            # return new data iteration by iteration
+            yield X_next, Y_next
+
+    def __str__(self):
+        return \
+            '========== Framework Description ==========\n' + \
+            f'# algorithm: {self.__class__.__name__}\n' + \
+            f'# surrogate: {self.surrogate_model.__class__.__name__}\n' + \
+            f'# acquisition: {self.acquisition.__class__.__name__}\n' + \
+            f'# solver: {self.solver.__class__.__name__}\n' + \
+            f'# selection: {self.selection.__class__.__name__}\n'

moospread/utils/mobo_utils/mobo/selection.py

@@ -0,0 +1,182 @@
+from abc import ABC, abstractmethod
+import numpy as np
+from sklearn.cluster import KMeans
+from pymoo.factory import get_performance_indicator
+from pymoo.algorithms.nsga2 import calc_crowding_distance
+
+'''
+Selection methods for new batch of samples to evaluate on real problem
+'''
+
+class Selection(ABC):
+    '''
+    Base class of selection method
+    '''
+    def __init__(self, batch_size, ref_point=None, **kwargs):
+        self.batch_size = batch_size
+        self.ref_point = ref_point
+
+    def fit(self, X, Y):
+        '''
+        Fit the parameters of selection method from data
+        '''
+        pass
+
+    def set_ref_point(self, ref_point):
+        self.ref_point = ref_point
+
+    @abstractmethod
+    def select(self, solution, surrogate_model, status, transformation):
+        '''
+        Select new samples from solution obtained by solver
+        Input:
+            solution['x']: design variables of solution
+            solution['y']: acquisition values of solution
+            solution['algo']: solver algorithm, having some relevant information from optimization
+            surrogate_model: fitted surrogate model
+            status['pset']: current pareto set found
+            status['pfront]: current pareto front found
+            status['hv']: current hypervolume
+            transformation: data normalization for surrogate model fitting
+            (some inputs may not be necessary for some selection criterion)
+        Output:
+            X_next: next batch of samples selected
+            info: other informations need to be stored or exported, None if not necessary
+        '''
+        pass
+
+
+class HVI(Selection):
+    '''
+    Hypervolume Improvement
+    '''
+    def select(self, solution, surrogate_model, status, transformation):
+
+        pred_pset = solution['x']
+        val = surrogate_model.evaluate(pred_pset)
+        pred_pfront = val['F']
+        pred_pset, pred_pfront = transformation.undo(pred_pset, pred_pfront)
+
+        curr_pfront = status['pfront'].copy()
+        hv = get_performance_indicator('hv', ref_point=self.ref_point)
+        idx_choices = np.ma.array(np.arange(len(pred_pset)), mask=False) # mask array for index choices
+        next_batch_indices = []
+
+        # greedily select indices that maximize hypervolume contribution
+        for _ in range(self.batch_size):
+            curr_hv = hv.calc(curr_pfront)
+            max_hv_contrib = 0.
+            max_hv_idx = -1
+            for idx in idx_choices.compressed():
+                # calculate hypervolume contribution
+                new_hv = hv.calc(np.vstack([curr_pfront, pred_pfront[idx]]))
+                hv_contrib = new_hv - curr_hv
+                if hv_contrib > max_hv_contrib:
+                    max_hv_contrib = hv_contrib
+                    max_hv_idx = idx
+            if max_hv_idx == -1: # if all candidates have no hypervolume contribution, just randomly select one
+                max_hv_idx = np.random.choice(idx_choices.compressed())
+
+            idx_choices.mask[max_hv_idx] = True # mask as selected
+            curr_pfront = np.vstack([curr_pfront, pred_pfront[max_hv_idx]]) # add to current pareto front
+            next_batch_indices.append(max_hv_idx)
+        next_batch_indices = np.array(next_batch_indices)
+
+        return pred_pset[next_batch_indices], None
+
+
+class Uncertainty(Selection):
+    '''
+    Uncertainty
+    '''
+    def select(self, solution, surrogate_model, status, transformation):
+
+        X = solution['x']
+        val = surrogate_model.evaluate(X, std=True)
+        Y_std = val['S']
+        X = transformation.undo(x=X)
+
+        uncertainty = np.prod(Y_std, axis=1)
+        top_indices = np.argsort(uncertainty)[::-1][:self.batch_size]
+        return X[top_indices], None
+
+
+class Random(Selection):
+    '''
+    Random selection
+    '''
+    def select(self, solution, surrogate_model, status, transformation):
+        X = solution['x']
+        X = transformation.undo(x=X)
+        random_indices = np.random.choice(len(X), size=self.batch_size, replace=False)
+        return X[random_indices], None
+
+
+class DGEMOSelect(Selection):
+    '''
+    Selection method for DGEMO algorithm
+    '''
+    has_family = True
+
+    def select(self, solution, surrogate_model, status, transformation):
+        algo = solution['algo']
+
+        X_next, _, family_lbls_next = algo.propose_next_batch(status['pfront'], self.ref_point, self.batch_size, transformation)
+        family_lbls, approx_pset, approx_pfront = algo.get_sparse_front(transformation)
+
+        info = {
+            'family_lbls_next': family_lbls_next,
+            'family_lbls': family_lbls,
+            'approx_pset': approx_pset,
+            'approx_pfront': approx_pfront,
+        }
+        return X_next, info
+
+
+class MOEADSelect(Selection):
+    '''
+    Selection method for MOEA/D-EGO algorithm
+    '''
+    def select(self, solution, surrogate_model, status, transformation): 
+        X, G, algo = solution['x'], solution['y'], solution['algo']
+        ref_dirs = algo.ref_dirs
+
+        G_s = algo._decomposition.do(G, weights=ref_dirs, ideal_point=algo.ideal_point) # scalarized acquisition value
+
+        # build candidate pool Q
+        Q_x, Q_dir, Q_g = [], [], []
+        X_added = status['pset'].copy()
+        for x, ref_dir, g in zip(X, ref_dirs, G_s):
+            if (x != X_added).any(axis=1).all():
+                Q_x.append(x)
+                Q_dir.append(ref_dir)
+                Q_g.append(g)
+                X_added = np.vstack([X_added, x])
+        Q_x, Q_dir, Q_g = np.array(Q_x), np.array(Q_dir), np.array(Q_g)
+
+        batch_size = min(self.batch_size, len(Q_x)) # in case Q is smaller than batch size
+
+        if batch_size == 0:
+            X_next = X[np.random.choice(len(X), self.batch_size, replace=False)]
+            X_next = transformation.undo(x=X_next)
+            return X_next, None
+        
+        # k-means clustering on X with weight vectors
+        labels = KMeans(n_clusters=batch_size).fit_predict(np.column_stack([Q_x, Q_dir]))
+
+        # select point in each cluster with lowest scalarized acquisition value
+        X_next = []
+        for i in range(batch_size):
+            indices = np.where(labels == i)[0]
+            top_idx = indices[np.argmin(Q_g[indices])]
+            top_x = transformation.undo(x=Q_x[top_idx])
+            X_next.append(top_x)
+        X_next = np.array(X_next)
+
+        # when Q is smaller than batch size
+        if batch_size < self.batch_size:
+            X_rest = X[np.random.choice(len(X), self.batch_size - batch_size, replace=False)]
+            X_next = np.vstack([X_next, transformation.undo(x=X_rest)])
+
+        return X_next, None
+

moospread/utils/mobo_utils/mobo/solver/__init__.py

@@ -0,0 +1,5 @@
+from moospread.utils.mobo_utils.mobo.solver.solver import Solver
+from moospread.utils.mobo_utils.mobo.solver.nsga2 import NSGA2Solver
+from moospread.utils.mobo_utils.mobo.solver.moead import MOEADSolver
+from moospread.utils.mobo_utils.mobo.solver.pareto_discovery import ParetoDiscoverySolver
+from moospread.utils.mobo_utils.mobo.solver.parego import ParEGOSolver

moospread/utils/mobo_utils/mobo/solver/moead.py

@@ -0,0 +1,17 @@
+from moospread.utils.mobo_utils.mobo.solver.solver import Solver
+import numpy as np
+from pymoo.algorithms.moead import MOEAD
+
+
+class MOEADSolver(Solver):
+    '''
+    Solver based on MOEA/D
+    '''
+    def __init__(self, *args, **kwargs):
+        pop_size, n_obj = kwargs['pop_size'], kwargs['n_obj']
+        # generate direction vectors by random sampling
+        ref_dirs = np.random.random((pop_size, n_obj))
+        ref_dirs /= np.expand_dims(np.sum(ref_dirs, axis=1), 1)
+        kwargs['ref_dirs'] = ref_dirs
+        kwargs['eliminate_duplicates'] = False
+        super().__init__(*args, algo=MOEAD, **kwargs)

moospread/utils/mobo_utils/mobo/solver/nsga2.py

@@ -0,0 +1,10 @@
+from moospread.utils.mobo_utils.mobo.solver.solver import Solver
+from pymoo.algorithms.nsga2 import NSGA2
+
+
+class NSGA2Solver(Solver):
+    '''
+    Solver based on NSGA-II
+    '''
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, algo=NSGA2, **kwargs)

moospread/utils/mobo_utils/mobo/solver/parego/__init__.py

@@ -0,0 +1 @@
+from moospread.utils.mobo_utils.mobo.solver.parego import ParEGOSolver

moospread/utils/mobo_utils/mobo/solver/parego/parego.py

@@ -0,0 +1,62 @@
+import numpy as np
+from moospread.utils.mobo_utils.mobo.solver.solver import Solver
+from pymoo.optimize import minimize
+from pymoo.algorithms.so_cmaes import CMAES
+from pymoo.decomposition.tchebicheff import Tchebicheff
+from moospread.utils.mobo_utils.mobo.solver.parego.utils import ScalarizedEvaluator
+from multiprocessing import Process, Queue
+
+
+def optimization(problem, x, weights, queue):
+    '''
+    Parallel worker for single-objective CMA-ES optimization
+    '''
+    evaluator = ScalarizedEvaluator(decomposition=Tchebicheff(), weights=weights)
+    res = minimize(problem, CMAES(x), evaluator=evaluator)
+    queue.put([res.X[0], res.F[0]])
+
+
+class ParEGOSolver(Solver):
+    '''
+    Solver based on ParEGO
+    '''
+    def __init__(self, *args, **kwargs):
+        self.pop_size = kwargs['pop_size']
+        self.n_process = kwargs.pop('n_process')
+        super().__init__(*args, algo=CMAES, **kwargs)
+
+    def solve(self, problem, X, Y):
+        '''
+        Solve the multi-objective problem by multiple scalarized single-objective solvers
+        '''
+        # initialize population
+        sampling = self._get_sampling(X, Y)
+        if not isinstance(sampling, np.ndarray):
+            sampling = sampling.do(problem, self.pop_size)
+
+        # generate scalarization weights
+        weights = np.random.random((self.pop_size, Y.shape[1]))
+        weights /= np.expand_dims(np.sum(weights, axis=1), 1)
+
+        # optimization
+        xs, ys = [], []
+        queue = Queue()
+        n_active_process = 0
+        for i, x0 in enumerate(sampling):
+            Process(target=optimization, args=(problem, x0, weights[i], queue)).start()
+            n_active_process += 1
+            if n_active_process >= self.n_process:
+                x, y = queue.get()
+                xs.append(x)
+                ys.append(y)
+                n_active_process -= 1
+
+        # gather result
+        for _ in range(n_active_process):
+            x, y = queue.get()
+            xs.append(x)
+            ys.append(y)
+        
+        # construct solution
+        self.solution = {'x': np.array(xs), 'y': np.array(ys)}
+        return self.solution

moospread/utils/mobo_utils/mobo/solver/parego/utils.py

@@ -0,0 +1,34 @@
+import numpy as np
+from pymoo.model.evaluator import Evaluator
+
+'''
+Evaluate a scalar value of a multi-objective problem by scalarization (decomposition)
+'''
+
+class ScalarizedEvaluator(Evaluator):
+
+    def __init__(self, *args, decomposition, weights, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.decomposition = decomposition
+        self.weights = weights
+        self.ideal_point = None
+
+    def _eval(self, problem, pop, **kwargs):
+
+        out = problem.evaluate(pop.get("X"),
+                               return_values_of=self.evaluate_values_of,
+                               return_as_dictionary=True,
+                               **kwargs)
+
+        for key, val in out.items():
+            if val is None:
+                continue
+            else:
+                if key == 'F':
+                    if self.ideal_point is None:
+                        self.ideal_point = np.min(val, axis=0)
+                    else:
+                        self.ideal_point = np.minimum(self.ideal_point, np.min(val, axis=0))
+                    val = self.decomposition.do(val, self.weights, ideal_point=self.ideal_point)
+                    if len(val) > 1: val = np.expand_dims(val, 1)
+                pop.set(key, val)

moospread/utils/mobo_utils/mobo/solver/pareto_discovery/__init__.py

@@ -0,0 +1 @@
+from moospread.utils.mobo_utils.mobo.solver.pareto_discovery import ParetoDiscoverySolver