def get_gp(n_dimensions, rs, noise=-8):
cov_amp = 2
initial_ls = np.ones([n_dimensions])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dimensions)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1, rng=rs)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
bounds = [(0., 1.) for _ in range(n_dimensions)]
types = np.zeros(n_dimensions)
model = GaussianProcessMCMC(
types=types,
bounds=bounds,
kernel=kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=20,
burnin_steps=100,
normalize_input=True,
normalize_output=True,
rng=rs,
noise=noise,
)
return model
def get_gp(n_dimensions,
rs,
noise=1e-3,
normalize_y=True,
average_samples=False,
n_iter=50):
from smac.epm.gp_kernels import ConstantKernel, Matern, WhiteKernel
cov_amp = ConstantKernel(
2.0,
constant_value_bounds=(1e-10, 2),
prior=LognormalPrior(mean=0.0, sigma=1.0, rng=rs),
)
exp_kernel = Matern(
np.ones([n_dimensions]),
[(np.exp(-10), np.exp(2)) for _ in range(n_dimensions)],
nu=2.5,
prior=None,
)
noise_kernel = WhiteKernel(
noise_level=noise,
noise_level_bounds=(1e-10, 2),
prior=HorseshoePrior(scale=0.1, rng=rs),
)
kernel = cov_amp * exp_kernel + noise_kernel
n_mcmc_walkers = 3 * len(kernel.theta)
if n_mcmc_walkers % 2 == 1:
n_mcmc_walkers += 1
bounds = [(0., 1.) for _ in range(n_dimensions)]
types = np.zeros(n_dimensions)
configspace = ConfigurationSpace()
for i in range(n_dimensions):
configspace.add_hyperparameter(
UniformFloatHyperparameter('x%d' % i, 0, 1))
model = GaussianProcessMCMC(
configspace=configspace,
types=types,
bounds=bounds,
kernel=kernel,
n_mcmc_walkers=n_mcmc_walkers,
chain_length=n_iter,
burnin_steps=n_iter,
normalize_y=normalize_y,
seed=rs.randint(low=1, high=10000),
mcmc_sampler='emcee',
average_samples=average_samples,
)
return model
def _component_builder(self, conf:typing.Union[Configuration, dict]) \
-> typing.Tuple[AbstractAcquisitionFunction, AbstractEPM]:
"""
builds new Acquisition function object
and EPM object and returns these
Parameters
----------
conf: typing.Union[Configuration, dict]
configuration specificing "model" and "acq_func"
Returns
-------
typing.Tuple[AbstractAcquisitionFunction, AbstractEPM]
"""
types, bounds = get_types(
self.config_space, instance_features=self.scenario.feature_array)
if conf["model"] == "RF":
model = RandomForestWithInstances(
configspace=self.config_space,
types=types,
bounds=bounds,
instance_features=self.scenario.feature_array,
seed=self.rng.randint(MAXINT),
pca_components=conf.get("pca_dim", self.scenario.PCA_DIM),
log_y=conf.get("log_y", self.scenario.transform_y
in ["LOG", "LOGS"]),
num_trees=conf.get("num_trees", self.scenario.rf_num_trees),
do_bootstrapping=conf.get("do_bootstrapping",
self.scenario.rf_do_bootstrapping),
ratio_features=conf.get("ratio_features",
self.scenario.rf_ratio_features),
min_samples_split=conf.get("min_samples_split",
self.scenario.rf_min_samples_split),
min_samples_leaf=conf.get("min_samples_leaf",
self.scenario.rf_min_samples_leaf),
max_depth=conf.get("max_depth", self.scenario.rf_max_depth),
)
elif conf["model"] == "GP":
from smac.epm.gp_kernels import ConstantKernel, HammingKernel, WhiteKernel, Matern
cov_amp = ConstantKernel(
2.0,
constant_value_bounds=(np.exp(-10), np.exp(2)),
prior=LognormalPrior(mean=0.0, sigma=1.0, rng=self.rng),
)
cont_dims = np.nonzero(types == 0)[0]
cat_dims = np.nonzero(types != 0)[0]
if len(cont_dims) > 0:
exp_kernel = Matern(
np.ones([len(cont_dims)]),
[(np.exp(-10), np.exp(2)) for _ in range(len(cont_dims))],
nu=2.5,
operate_on=cont_dims,
)
if len(cat_dims) > 0:
ham_kernel = HammingKernel(
np.ones([len(cat_dims)]),
[(np.exp(-10), np.exp(2)) for _ in range(len(cat_dims))],
operate_on=cat_dims,
)
noise_kernel = WhiteKernel(
noise_level=1e-8,
noise_level_bounds=(np.exp(-25), np.exp(2)),
prior=HorseshoePrior(scale=0.1, rng=self.rng),
)
if len(cont_dims) > 0 and len(cat_dims) > 0:
# both
kernel = cov_amp * (exp_kernel * ham_kernel) + noise_kernel
elif len(cont_dims) > 0 and len(cat_dims) == 0:
# only cont
kernel = cov_amp * exp_kernel + noise_kernel
elif len(cont_dims) == 0 and len(cat_dims) > 0:
# only cont
kernel = cov_amp * ham_kernel + noise_kernel
else:
raise ValueError()
n_mcmc_walkers = 3 * len(kernel.theta)
if n_mcmc_walkers % 2 == 1:
n_mcmc_walkers += 1
model = GaussianProcessMCMC(
self.config_space,
types=types,
bounds=bounds,
kernel=kernel,
n_mcmc_walkers=n_mcmc_walkers,
chain_length=250,
burnin_steps=250,
normalize_y=True,
seed=self.rng.randint(low=0, high=10000),
)
if conf["acq_func"] == "EI":
acq = EI(model=model, par=conf.get("par_ei", 0))
elif conf["acq_func"] == "LCB":
acq = LCB(model=model, par=conf.get("par_lcb", 0))
elif conf["acq_func"] == "PI":
acq = PI(model=model, par=conf.get("par_pi", 0))
elif conf["acq_func"] == "LogEI":
# par value should be in log-space
acq = LogEI(model=model, par=conf.get("par_logei", 0))
return acq, model
def __init__(self, model_type='gp_mcmc', **kwargs):
"""
Constructor
see ~smac.facade.smac_facade for documentation
"""
scenario = kwargs['scenario']
if scenario.initial_incumbent not in ['LHD', 'FACTORIAL', 'SOBOL']:
scenario.initial_incumbent = 'SOBOL'
if scenario.transform_y is 'NONE':
scenario.transform_y = "LOGS"
if kwargs.get('model') is None:
_, rng = get_rng(rng=kwargs.get("rng", None),
run_id=kwargs.get("run_id", None),
logger=None)
cov_amp = 2
types, bounds = get_types(kwargs['scenario'].cs,
instance_features=None)
n_dims = len(types)
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1, rng=rng)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model_type == "gp":
model = GaussianProcess(
types=types,
bounds=bounds,
kernel=kernel,
prior=prior,
rng=rng,
normalize_output=True,
normalize_input=True,
)
elif model_type == "gp_mcmc":
model = GaussianProcessMCMC(
types=types,
bounds=bounds,
kernel=kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=True,
rng=rng,
)
kwargs['model'] = model
super().__init__(**kwargs)
if self.solver.scenario.n_features > 0:
raise NotImplementedError("BOGP cannot handle instances")
self.logger.info(self.__class__)
self.solver.random_configuration_chooser.prob = 0.0
# only 1 configuration per SMBO iteration
self.solver.scenario.intensification_percentage = 1e-10
self.solver.intensifier.min_chall = 1
# better improve acqusition function optimization
# 1. increase number of sls iterations
self.solver.acq_optimizer.n_sls_iterations = 100
# 2. more randomly sampled configurations
self.solver.scenario.acq_opt_challengers = 1000
# activate predict incumbent
self.solver.predict_incumbent = True
def _component_builder(self, conf:typing.Union[Configuration, dict]) \
-> typing.Tuple[AbstractAcquisitionFunction, AbstractEPM]:
"""
builds new Acquisition function object
and EPM object and returns these
Parameters
----------
conf: typing.Union[Configuration, dict]
configuration specificing "model" and "acq_func"
Returns
-------
typing.Tuple[AbstractAcquisitionFunction, AbstractEPM]
"""
types, bounds = get_types(self.config_space, instance_features=self.scenario.feature_array)
if conf["model"] == "RF":
model = RandomForestWithInstances(
types=types,
bounds=bounds,
instance_features=self.scenario.feature_array,
seed=self.rng.randint(MAXINT),
pca_components=conf.get("pca_dim", self.scenario.PCA_DIM),
log_y=conf.get("log_y", self.scenario.transform_y in ["LOG", "LOGS"]),
num_trees=conf.get("num_trees", self.scenario.rf_num_trees),
do_bootstrapping=conf.get("do_bootstrapping", self.scenario.rf_do_bootstrapping),
ratio_features=conf.get("ratio_features", self.scenario.rf_ratio_features),
min_samples_split=conf.get("min_samples_split", self.scenario.rf_min_samples_split),
min_samples_leaf=conf.get("min_samples_leaf", self.scenario.rf_min_samples_leaf),
max_depth=conf.get("max_depth", self.scenario.rf_max_depth))
elif conf["model"] == "GP":
cov_amp = 2
n_dims = len(types)
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1, rng=self.rng)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
model = GaussianProcessMCMC(
types=types,
bounds=bounds,
kernel=kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=True,
rng=self.rng,
)
if conf["acq_func"] == "EI":
acq = EI(model=model,
par=conf.get("par_ei", 0))
elif conf["acq_func"] == "LCB":
acq = LCB(model=model,
par=conf.get("par_lcb", 0))
elif conf["acq_func"] == "PI":
acq = PI(model=model,
par=conf.get("par_pi", 0))
elif conf["acq_func"] == "LogEI":
# par value should be in log-space
acq = LogEI(model=model,
par=conf.get("par_logei", 0))
return acq, model