moospread 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,168 @@
+import numpy as np
+from pymoo.factory import get_performance_indicator
+
+
+def propose_next_batch(curr_pfront, ref_point, pred_pfront, pred_pset, batch_size, labels):
+    '''
+    Propose next batch of design variables to evaluate by maximizing hypervolume contribution.
+    Greedely add samples with maximum hypervolume from each family.
+    Input:
+        curr_pfront: current pareto front of evaluated design samples
+        pred_pfront: predicted pareto front from sampled objective functions
+        pred_pset: predicted pareto set from sampled objective functions
+        batch_size: batch size of design samples to be proposed
+        labels: family labels for pred_pset
+    Output:
+        X_next: next batch of design variables to evaluate
+        Y_next: expected output of next batch of design variables to evaluate
+        family_lbls: family labels of proposed batch samples
+    '''
+    #assert len(pred_pset) >= batch_size, "predicted pareto set is smaller than proposed batch size!"
+
+    curr_pfront = curr_pfront.copy()
+    hv = get_performance_indicator('hv', ref_point=ref_point)
+    idx_choices = np.ma.array(np.arange(len(pred_pset)), mask=False) # mask array for index choices
+    iter_idx_choices = np.ma.array(np.arange(len(pred_pset)), mask=False) # mask array for index choices of unvisited family samples
+    next_batch_indices = []
+    family_lbls_next = []
+    num_families = len(np.unique(labels))
+    print('Number of families is: '+str(num_families))
+
+    if len(pred_pset) < batch_size:
+        print('Predicted pareto set is smaller than proposed batch size and has '+ str(len(pred_pset)) +' points.')
+        next_batch_indices = [0] * (batch_size - len(pred_pset))
+        batch_size = len(pred_pset)
+
+    # greedily select indices that maximize hypervolume contribution
+    for _ in range(batch_size):
+        #if all families were visited, start new cycle
+        if len(iter_idx_choices.compressed())==0:
+            iter_idx_choices = idx_choices.copy()
+        curr_hv = hv.calc(curr_pfront)
+        max_hv_contrib = 0.
+        max_hv_idx = -1
+        for idx in iter_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(iter_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)
+        family_lbls_next.append(labels[max_hv_idx])
+        #find which family to mask all family memebers as visited in this cycle
+        family_ids = np.where(labels == labels[max_hv_idx])[0]
+        for fid in family_ids:
+            iter_idx_choices.mask[fid] = True
+
+    X_next = pred_pset[next_batch_indices].copy()
+    Y_next = pred_pfront[next_batch_indices].copy()
+    return X_next, Y_next, family_lbls_next
+
+
+def propose_next_batch_without_label(curr_pfront, ref_point, pred_pfront, pred_pset, batch_size):
+    '''
+    Propose next batch of design variables to evaluate by maximizing hypervolume contribution
+    Input:
+        curr_pfront: current pareto front of evaluated design samples
+        pred_pfront: predicted pareto front from sampled objective functions
+        pred_pset: predicted pareto set from sampled objective functions
+        batch_size: batch size of design samples to be proposed
+    Output:
+        X_next: next batch of design variables to evaluate
+    '''
+    #assert len(pred_pset) >= batch_size, "predicted pareto set is smaller than proposed batch size!
+
+    curr_pfront = curr_pfront.copy()
+    hv = get_performance_indicator('hv', ref_point=ref_point)
+    idx_choices = np.ma.array(np.arange(len(pred_pset)), mask=False) # mask array for index choices
+    next_batch_indices = []
+
+    if len(pred_pset) < batch_size:
+        print('Predicted pareto set is smaller than proposed batch size and has '+ str(len(pred_pset)) +' points.')
+        next_batch_indices = [0] * (batch_size - len(pred_pset))
+        batch_size = len(pred_pset)
+
+    # greedily select indices that maximize hypervolume contribution
+    for _ in range(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)
+
+    X_next = pred_pset[next_batch_indices].copy()
+    Y_next = pred_pfront[next_batch_indices].copy()
+    return X_next, Y_next
+
+
+def generate_weights_batch_dfs(i, n_dim, min_weight, max_weight, delta_weight, weight, weights_batch):
+    if i == n_dim - 1:
+        weight.append(1.0 - np.sum(weight[0:i]))
+        weights_batch.append(weight.copy())
+        weight = weight[0:i]
+        return
+    w = min_weight
+    while w < max_weight + 0.5 * delta_weight and np.sum(weight[0:i]) + w < 1.0 + 0.5 * delta_weight:
+        weight.append(w)
+        generate_weights_batch_dfs(i + 1, n_dim, min_weight, max_weight, delta_weight, weight, weights_batch)
+        weight = weight[0:i]
+        w += delta_weight
+
+
+def generate_weights_batch(n_dim, delta_weight):
+    '''
+    Generate n dimensional uniformly distributed weights using depth first search.
+    e.g. generate_weights_batch(2, 0.5) returns [[0.0, 1.0], [0.5, 0.5], [1.0, 0.0]]
+    '''
+    weights_batch = []
+    generate_weights_batch_dfs(0, n_dim, 0.0, 1.0, delta_weight, [], weights_batch)
+    return np.array(weights_batch)
+
+
+def get_sample_num_from_families(n_sample, family_sizes):
+    '''
+    Choose certain number of samples from all families, as uniformly as possible.
+    Input:
+        n_sample: total number of samples to be chosen
+        family_sizes: array containing size of each family, shape = (n_family,)
+    Output:
+        sample_nums: number of samples we choose from each samily, shape = (n_family,)
+    '''
+    assert np.sum(family_sizes) >= n_sample
+
+    family_sizes = np.array(family_sizes, dtype=np.int32)
+    valid_idx = np.where(family_sizes > 0)[0]
+    valid_family_sizes = family_sizes[valid_idx]
+    n_family = len(valid_idx)
+    sample_nums = np.zeros_like(family_sizes, dtype=np.int32)
+
+    if n_sample > n_family:
+        # distribute n_sample to n_family as uniformly as possible
+        curr_n_sample_each_fam = min(n_sample // n_family, np.min(valid_family_sizes))
+        remain_n_sample = n_sample - curr_n_sample_each_fam * n_family
+        remain_family_sizes = valid_family_sizes - curr_n_sample_each_fam
+        sample_nums[valid_idx] += curr_n_sample_each_fam
+        sample_nums[valid_idx] += get_sample_num_from_families(remain_n_sample, remain_family_sizes)
+    else:
+        # randomly choose n_sample families to sample
+        random_idx = np.random.choice(np.arange(n_family), n_sample, replace=False)
+        sample_nums[valid_idx[random_idx]] = 1
+
+    return sample_nums

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

@@ -0,0 +1,74 @@
+import numpy as np
+from pymoo.optimize import minimize
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.operators.sampling.random_sampling import FloatRandomSampling
+from pymoo.operators.sampling.latin_hypercube_sampling import LatinHypercubeSampling
+from external import lhs
+
+
+class Solver:
+    '''
+    Multi-objective solver
+    '''
+    def __init__(self, n_gen, pop_init_method, batch_size, algo, **kwargs):
+        '''
+        Input:
+            n_gen: number of generations to solve
+            pop_init_method: method to initialize population
+            algo: class of multi-objective algorithm to use
+            kwargs: other keyword arguments for algorithm to initialize
+        '''
+        self.n_gen = n_gen
+        self.pop_init_method = pop_init_method
+        self.batch_size = batch_size
+        self.algo_type = algo
+        self.algo_kwargs = kwargs
+        self.solution = None
+
+    def solve(self, problem, X, Y):
+        '''
+        Solve the multi-objective problem
+        '''
+        # initialize population
+        sampling = self._get_sampling(X, Y)
+
+        # setup algorithm
+        algo = self.algo_type(sampling=sampling, **self.algo_kwargs)
+
+        # optimization
+        res = minimize(problem, algo, ('n_gen', self.n_gen))
+
+        # construct solution
+        self.solution = {'x': res.pop.get('X'), 'y': res.pop.get('F'), 'algo': res.algorithm}
+
+        # fill the solution in case less than batch size
+        pop_size = len(self.solution['x'])
+        if pop_size < self.batch_size:
+            indices = np.concatenate([np.arange(pop_size), np.random.choice(np.arange(pop_size), self.batch_size - pop_size)])
+            self.solution['x'] = np.array(self.solution['x'])[indices]
+            self.solution['y'] = np.array(self.solution['y'])[indices]
+
+        return self.solution
+
+    def _get_sampling(self, X, Y):
+        '''
+        Initialize population from data
+        '''
+        if self.pop_init_method == 'lhs':
+            sampling = LatinHypercubeSampling()
+        elif self.pop_init_method == 'nds':
+            sorted_indices = NonDominatedSorting().do(Y)
+            pop_size = self.algo_kwargs['pop_size']
+            sampling = X[np.concatenate(sorted_indices)][:pop_size]
+            # NOTE: use lhs if current samples are not enough
+            if len(sampling) < pop_size:
+                rest_sampling = lhs(X.shape[1], pop_size - len(sampling))
+                sampling = np.vstack([sampling, rest_sampling])
+        elif self.pop_init_method == 'random':
+            sampling = FloatRandomSampling()
+        else:
+            raise NotImplementedError
+
+        return sampling
+
+

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

@@ -0,0 +1,2 @@
+from moospread.utils.mobo_utils.mobo.surrogate_model.gaussian_process import GaussianProcess
+from moospread.utils.mobo_utils.mobo.surrogate_model.thompson_sampling import ThompsonSampling

moospread/utils/mobo_utils/mobo/surrogate_model/base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+
+'''
+Surrogate model that predicts the performance of given design variables
+'''
+
+class SurrogateModel(ABC):
+    '''
+    Base class of surrogate model
+    '''
+    def __init__(self, n_var, n_obj):
+        self.n_var = n_var
+        self.n_obj = n_obj
+
+    @abstractmethod
+    def fit(self, X, Y):
+        '''
+        Fit the surrogate model from data (X, Y)
+        '''
+        pass
+
+    @abstractmethod
+    def evaluate(self, X, std=False, calc_gradient=False, calc_hessian=False):
+        '''
+        Predict the performance given set of design variables X
+        Input:
+            std / calc_gradient / calc_hessian : whether to calculate std / gradient / hessian of prediction
+        Output:
+            val['F']: mean, shape (N, n_obj)
+            val['dF']: gradient of mean, shape (N, n_obj, n_var)
+            val['hF']: hessian of mean, shape (N, n_obj, n_var, n_var)
+            val['S']: std, shape (N, n_obj)
+            val['dS']: gradient of std, shape (N, n_obj, n_var)
+            val['hS']: hessian of std, shape (N, n_obj, n_var, n_var)
+        '''
+        pass

moospread/utils/mobo_utils/mobo/surrogate_model/gaussian_process.py

@@ -0,0 +1,177 @@
+import numpy as np
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import Matern, RBF, ConstantKernel
+from sklearn.utils.optimize import _check_optimize_result
+from scipy.optimize import minimize
+from scipy.linalg import solve_triangular
+from scipy.spatial.distance import cdist
+
+from moospread.utils.mobo_utils.mobo.surrogate_model.base import SurrogateModel
+from moospread.utils.mobo_utils.mobo.utils import safe_divide
+
+
+class GaussianProcess(SurrogateModel):
+    
+    def warn(*args, **kwargs):
+        pass
+    import warnings
+    warnings.warn = warn
+    
+    '''
+    Gaussian process
+    '''
+    def __init__(self, n_var, n_obj, nu, **kwargs):
+        super().__init__(n_var, n_obj)
+        
+        self.nu = nu
+        self.gps = []
+
+        def constrained_optimization(obj_func, initial_theta, bounds):
+            opt_res = minimize(obj_func, initial_theta, method="L-BFGS-B", jac=True, bounds=bounds)
+            '''
+            NOTE: Temporarily disable the checking below because this error sometimes occurs:
+                ConvergenceWarning: lbfgs failed to converge (status=2):
+                ABNORMAL_TERMINATION_IN_LNSRCH
+                , though we already optimized enough number of iterations and scaled the data.
+                Still don't know the exact reason of this yet.
+            '''
+            # _check_optimize_result("lbfgs", opt_res)
+            return opt_res.x, opt_res.fun
+
+        for _ in range(n_obj):
+            if nu > 0:
+                main_kernel = Matern(length_scale=np.ones(n_var), length_scale_bounds=(np.sqrt(1e-3), np.sqrt(1e3)), nu=0.5 * nu)
+            else:
+                main_kernel = RBF(length_scale=np.ones(n_var), length_scale_bounds=(np.sqrt(1e-3), np.sqrt(1e3)))
+            
+            kernel = ConstantKernel(constant_value=1.0, constant_value_bounds=(np.sqrt(1e-3), np.sqrt(1e3))) * \
+                main_kernel + \
+                ConstantKernel(constant_value=1e-2, constant_value_bounds=(np.exp(-6), np.exp(0)))
+            
+            gp = GaussianProcessRegressor(kernel=kernel, optimizer=constrained_optimization)
+            self.gps.append(gp)
+
+    def fit(self, X, Y):
+        for i, gp in enumerate(self.gps):
+            gp.fit(X, Y[:, i])
+        
+    def evaluate(self, X, std=False, calc_gradient=False, calc_hessian=False):
+        F, dF, hF = [], [], [] # mean
+        S, dS, hS = [], [], [] # std
+
+        for gp in self.gps:
+
+            # mean
+            K = gp.kernel_(X, gp.X_train_) # K: shape (N, N_train)
+            y_mean = K.dot(gp.alpha_)
+            
+            F.append(y_mean) # y_mean: shape (N,)
+
+            if std:
+                
+                L_inv = solve_triangular(gp.L_.T,
+                                                np.eye(gp.L_.shape[0]))
+                K_inv = L_inv.dot(L_inv.T)
+
+                y_var = gp.kernel_.diag(X)
+                y_var -= np.einsum("ij,ij->i",
+                                    np.dot(K, K_inv), K)
+
+                y_var_negative = y_var < 0
+                if np.any(y_var_negative):
+                    y_var[y_var_negative] = 0.0
+
+                y_std = np.sqrt(y_var)
+
+                S.append(y_std) # y_std: shape (N,)
+
+            if not (calc_gradient or calc_hessian): continue
+
+            ell = np.exp(gp.kernel_.theta[1:-1]) # ell: shape (n_var,)
+            sf2 = np.exp(gp.kernel_.theta[0]) # sf2: shape (1,)
+            d = np.expand_dims(cdist(X / ell, gp.X_train_ / ell), 2) # d: shape (N, N_train, 1)
+            X_, X_train_ = np.expand_dims(X, 1), np.expand_dims(gp.X_train_, 0)
+            dd_N = X_ - X_train_ # numerator
+            dd_D = d * ell ** 2 # denominator
+            dd = safe_divide(dd_N, dd_D) # dd: shape (N, N_train, n_var)
+
+            if calc_gradient or calc_hessian:
+                if self.nu == 1:
+                    dK = -sf2 * np.exp(-d) * dd
+
+                elif self.nu == 3:
+                    dK = -3 * sf2 * np.exp(-np.sqrt(3) * d) * d * dd
+
+                elif self.nu == 5:
+                    dK = -5. / 3 * sf2 * np.exp(-np.sqrt(5) * d) * (1 + np.sqrt(5) * d) * d * dd
+
+                else: # RBF
+                    dK = -sf2 * np.exp(-0.5 * d ** 2) * d * dd
+
+                dK_T = dK.transpose(0, 2, 1) # dK: shape (N, N_train, n_var), dK_T: shape (N, n_var, N_train)
+                
+            if calc_gradient:
+                dy_mean = dK_T @ gp.alpha_ # gp.alpha_: shape (N_train,)
+                dF.append(dy_mean) # dy_mean: shape (N, n_var)
+
+                # TODO: check
+                if std:
+                    K = np.expand_dims(K, 1) # K: shape (N, 1, N_train)
+                    K_Ki = K @ K_inv # gp._K_inv: shape (N_train, N_train), K_Ki: shape (N, 1, N_train)
+                    dK_Ki = dK_T @ K_inv # dK_Ki: shape (N, n_var, N_train)
+
+                    dy_var = -np.sum(dK_Ki * K + K_Ki * dK_T, axis=2) # dy_var: shape (N, n_var)
+                    #print(dy_var.shape)
+                    #print(np.expand_dims(y_std,1).shape)
+                    #dy_std = 0.5 * safe_divide(dy_var, y_std) # dy_std: shape (N, n_var)
+                    if np.min(y_std) != 0:
+                        dy_std = 0.5 * dy_var / np.expand_dims(y_std,1) # dy_std: shape (N, n_var)
+                    else:
+                        dy_std=np.zeros(dy_var.shape)
+                    dS.append(dy_std)
+
+            if calc_hessian:
+                d = np.expand_dims(d, 3) # d: shape (N, N_train, 1, 1)
+                dd = np.expand_dims(dd, 2) # dd: shape (N, N_train, 1, n_var)
+                hd_N = d * np.expand_dims(np.eye(len(ell)), (0, 1)) - np.expand_dims(X_ - X_train_, 3) * dd # numerator
+                hd_D = d ** 2 * np.expand_dims(ell ** 2, (0, 1, 3)) # denominator
+                hd = safe_divide(hd_N, hd_D) # hd: shape (N, N_train, n_var, n_var)
+
+                if self.nu == 1:
+                    hK = -sf2 * np.exp(-d) * (hd - dd ** 2)
+
+                elif self.nu == 3:
+                    hK = -3 * sf2 * np.exp(-np.sqrt(3) * d) * (d * hd + (1 - np.sqrt(3) * d) * dd ** 2)
+
+                elif self.nu == 5:
+                    hK = -5. / 3 * sf2 * np.exp(-np.sqrt(5) * d) * (-5 * d ** 2 * dd ** 2 + (1 + np.sqrt(5) * d) * (dd ** 2 + d * hd))
+
+                else: # RBF
+                    hK = -sf2 * np.exp(-0.5 * d ** 2) * ((1 - d ** 2) * dd ** 2 + d * hd)
+
+                hK_T = hK.transpose(0, 2, 3, 1) # hK: shape (N, N_train, n_var, n_var), hK_T: shape (N, n_var, n_var, N_train)
+
+                hy_mean = hK_T @ gp.alpha_ # hy_mean: shape (N, n_var, n_var)
+                hF.append(hy_mean)
+
+                # TODO: check
+                if std:
+                    K = np.expand_dims(K, 2) # K: shape (N, 1, 1, N_train)
+                    dK = np.expand_dims(dK_T, 2) # dK: shape (N, n_var, 1, N_train)
+                    dK_Ki = np.expand_dims(dK_Ki, 2) # dK_Ki: shape (N, n_var, 1, N_train)
+                    hK_Ki = hK_T @ K_inv # hK_Ki: shape (N, n_var, n_var, N_train)
+
+                    hy_var = -np.sum(hK_Ki * K + 2 * dK_Ki * dK + K_Ki * hK_T, axis=3) # hy_var: shape (N, n_var, n_var)
+                    hy_std = 0.5 * safe_divide(hy_var * y_std - dy_var * dy_std, y_var) # hy_std: shape (N, n_var, n_var)
+                    hS.append(hy_std)
+
+        F = np.stack(F, axis=1)
+        dF = np.stack(dF, axis=1) if calc_gradient else None
+        hF = np.stack(hF, axis=1) if calc_hessian else None
+        
+        S = np.stack(S, axis=1) if std else None
+        dS = np.stack(dS, axis=1) if std and calc_gradient else None
+        hS = np.stack(hS, axis=1) if std and calc_hessian else None
+
+        out = {'F': F, 'dF': dF, 'hF': hF, 'S': S, 'dS': dS, 'hS': hS}
+        return out

moospread/utils/mobo_utils/mobo/surrogate_model/thompson_sampling.py

@@ -0,0 +1,79 @@
+import numpy as np
+from numpy import linalg as LA
+from scipy.stats.distributions import chi2
+from scipy.stats import norm
+
+import moospread.utils.mobo_utils.lhs_for_mobo as lhs
+from moospread.utils.mobo_utils.mobo.surrogate_model.gaussian_process import GaussianProcess
+
+
+class ThompsonSampling(GaussianProcess):
+    '''
+    Sampled functions from Gaussian process using Thompson Sampling
+    '''
+    def __init__(self, n_var, n_obj, nu, n_spectral_pts, mean_sample, **kwargs):
+        super().__init__(n_var, n_obj, nu)
+
+        self.M = n_spectral_pts
+        self.thetas, self.Ws, self.bs, self.sf2s = None, None, None, None
+        self.mean_sample = mean_sample
+
+    def fit(self, X, Y):
+        self.thetas, self.Ws, self.bs, self.sf2s = [], [], [], []
+        n_sample = X.shape[0]
+
+        for i, gp in enumerate(self.gps):
+            gp.fit(X, Y[:, i])
+
+            ell = np.exp(gp.kernel_.theta[1:-1])
+            sf2 = np.exp(2 * gp.kernel_.theta[0])
+            sn2 = np.exp(2 * gp.kernel_.theta[-1])
+
+            sw1, sw2 = lhs(self.n_var, self.M), lhs(self.n_var, self.M)
+            if self.nu > 0:
+                W = np.tile(1. / ell, (self.M, 1)) * norm.ppf(sw1) * np.sqrt(self.nu / chi2.ppf(sw2, df=self.nu))
+            else:
+                W = np.random.uniform(size=(self.M, self.n_var)) * np.tile(1. / ell, (self.M, 1))
+            b = 2 * np.pi * lhs(1, self.M)
+            phi = np.sqrt(2. * sf2 / self.M) * np.cos(W @ X.T + np.tile(b, (1, n_sample)))
+            A = phi @ phi.T + sn2 * np.eye(self.M)
+            invcholA = LA.inv(LA.cholesky(A))
+            invA = invcholA.T @ invcholA
+            mu_theta = invA @ phi @ Y[:, i]
+            if self.mean_sample:
+                theta = mu_theta
+            else:
+                cov_theta = sn2 * invA
+                cov_theta = 0.5 * (cov_theta + cov_theta.T)
+                theta = mu_theta + LA.cholesky(cov_theta) @ np.random.standard_normal(self.M)
+
+            self.thetas.append(theta.copy())
+            self.Ws.append(W.copy())
+            self.bs.append(b.copy())
+            self.sf2s.append(sf2)
+
+    def evaluate(self, X, std=False, calc_gradient=False, calc_hessian=False):
+        F, dF, hF = [], [], []
+        n_sample = X.shape[0] if len(X.shape) > 1 else 1
+
+        for theta, W, b, sf2 in zip(self.thetas, self.Ws, self.bs, self.sf2s):
+            factor = np.sqrt(2. * sf2 / self.M)
+            W_X_b = W @ X.T + np.tile(b, (1, n_sample))
+            F.append(factor * (theta @ np.cos(W_X_b)))
+
+            if calc_gradient:
+                dF.append(-factor * np.expand_dims(theta, 0) * np.sin(W_X_b).T @ W)
+            
+            if calc_hessian:
+                hF.append(-factor * np.einsum('ij,jk->ikj', np.expand_dims(theta, 0) * np.cos(W_X_b).T, W) @ W)
+            
+        F = np.stack(F, axis=1)
+        dF = np.stack(dF, axis=1) if calc_gradient else None
+        hF = np.stack(hF, axis=1) if calc_hessian else None
+
+        S = np.zeros((n_sample, self.n_obj)) if std else None
+        dS = np.zeros((n_sample, self.n_obj, self.n_var)) if std and calc_gradient else None
+        hS = np.zeros((n_sample, self.n_obj, self.n_var, self.n_var)) if std and calc_hessian else None
+        
+        out = {'F': F, 'dF': dF, 'hF': hF, 'S': S, 'dS': dS, 'hS': hS}
+        return out

moospread/utils/mobo_utils/mobo/surrogate_problem.py

@@ -0,0 +1,44 @@
+import numpy as np
+from problems import Problem
+
+'''
+Surrogate problem that mimics the real problem based on surrogate model
+'''
+
+class SurrogateProblem(Problem):
+
+    def __init__(self, real_problem, surrogate_model, acquisition, transformation):
+        '''
+        Input:
+            real_problem: the original optimization problem which this surrogate is approximating
+            surrogate_model: fitted surrogate model
+            acquisition: the acquisition function to evaluate the fitness of samples
+            transformation: data normalization for surrogate model fitting
+        '''
+        self.real_problem = real_problem
+        self.surrogate_model = surrogate_model
+        self.acquisition = acquisition
+        self.transformation = transformation
+        xl = transformation.do(x=real_problem.xl)
+        xu = transformation.do(x=real_problem.xu)
+        super().__init__(n_var=real_problem.n_var, n_obj=real_problem.n_obj, n_constr=real_problem.n_constr, xl=xl, xu=xu)
+
+    def evaluate(self, *args, return_values_of="auto", **kwargs):
+        assert self.surrogate_model is not None, 'surrogate model must be set first before evaluation'
+        
+        # handle hF (hessian) computation, which is not supported by Pymoo
+        calc_hessian = (type(return_values_of) == list and 'hF' in return_values_of)
+        
+        return super().evaluate(*args, return_values_of=return_values_of, calc_hessian=calc_hessian, **kwargs)
+
+    def _evaluate(self, x, out, *args, calc_gradient=False, calc_hessian=False, **kwargs):
+        # evaluate value by surrogate model
+        std = self.acquisition.requires_std
+        val = self.surrogate_model.evaluate(x, std, calc_gradient, calc_hessian)
+
+        # evaluate out['F/dF/hF'] by certain acquisition function
+        out['F'], out['dF'], out['hF'] = self.acquisition.evaluate(val, calc_gradient, calc_hessian)
+        
+        # evaluate constraints by real problem
+        x_ori = self.transformation.undo(x)
+        out['G'], out['CV'], out['feasible'] = self.real_problem.evaluate(x_ori, return_values_of=['G', 'CV', 'feasible'], requires_F=False)