def __init__(self,
config_space: ConfigurationSpace,
source_hpo_data: List,
seed: int,
history_dataset_features: List = None,
num_src_hpo_trial: int = 50,
surrogate_type='rf'):
self.method_id = None
self.config_space = config_space
self.random_seed = seed
self.num_src_hpo_trial = num_src_hpo_trial
self.source_hpo_data = source_hpo_data
self.source_surrogates = None
self.target_surrogate = None
self.history_dataset_features = history_dataset_features
# The number of en problems.
if source_hpo_data is not None:
self.K = len(source_hpo_data)
if history_dataset_features is not None:
assert len(history_dataset_features) == self.K
self.surrogate_type = surrogate_type
self.types, self.bounds = get_types(config_space)
self.instance_features = None
self.var_threshold = VERY_SMALL_NUMBER
self.w = None
self.eta_list = list()
# meta features.
self.meta_feature_scaler = None
self.meta_feature_imputer = None
self.target_weight = list()
self.logger = get_logger(self.__class__.__name__)
def setup_bo_basics(self):
if self.num_objs == 1:
self.surrogate_model = build_surrogate(func_str=self.surrogate_type,
config_space=self.config_space,
rng=self.rng,
history_hpo_data=self.history_bo_data)
else: # multi-objectives
self.surrogate_model = [build_surrogate(func_str=self.surrogate_type,
config_space=self.config_space,
rng=self.rng,
history_hpo_data=self.history_bo_data)
for _ in range(self.num_objs)]
if self.num_constraints > 0:
self.constraint_models = [build_surrogate(func_str=self.constraint_surrogate_type,
config_space=self.config_space,
rng=self.rng) for _ in range(self.num_constraints)]
self.acquisition_function = build_acq_func(func_str=self.acq_type, model=self.surrogate_model,
constraint_models=self.constraint_models,
mc_times=self.mc_times, ref_point=self.ref_point)
self.optimizer = build_optimizer(func_str=self.acq_optimizer_type,
acq_func=self.acquisition_function,
config_space=self.config_space,
rng=self.rng)
if self.use_trust_region:
types, bounds = get_types(self.config_space)
cont_dim = np.sum(types == 0)
self.turbo_state = TurboState(cont_dim)
def build_surrogate(func_str='prf',
config_space=None,
rng=None,
history_hpo_data=None):
assert config_space is not None
func_str = func_str.lower()
types, bounds = get_types(config_space)
seed = rng.randint(MAXINT)
if func_str == 'prf':
return RandomForestWithInstances(types=types, bounds=bounds, seed=seed)
if func_str == 'lightgbm':
return LightGBM(config_space, types=types, bounds=bounds, seed=seed)
elif func_str.startswith('gp'):
return create_gp_model(model_type=func_str,
config_space=config_space,
types=types,
bounds=bounds,
rng=rng)
elif func_str.startswith('mfgpe'):
from openbox.surrogate.tlbo.mfgpe import MFGPE
inner_surrogate_type = 'prf'
return MFGPE(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif func_str.startswith('tlbo'):
print('the current surrogate is', func_str)
if 'rgpe' in func_str:
from openbox.surrogate.tlbo.rgpe import RGPE
inner_surrogate_type = func_str.split('_')[-1]
return RGPE(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif 'sgpr' in func_str:
from openbox.surrogate.tlbo.stacking_gpr import SGPR
inner_surrogate_type = func_str.split('_')[-1]
return SGPR(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif 'topov3' in func_str:
from openbox.surrogate.tlbo.topo_variant3 import TOPO_V3
inner_surrogate_type = func_str.split('_')[-1]
return TOPO_V3(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
else:
raise ValueError('Invalid string %s for tlbo surrogate!' %
func_str)
else:
raise ValueError('Invalid string %s for surrogate!' % func_str)
def evaluate(mth, run_i, seed):
print(mth, run_i, seed, '===== start =====', flush=True)
def objective_function(config):
y = problem.evaluate_config(config)
return y
from cma import CMAEvolutionStrategy
from openbox.utils.util_funcs import get_types
from openbox.utils.config_space import Configuration
types, bounds = get_types(cs)
assert all(types == 0)
# Check Constant Hyperparameter
const_idx = list()
for i, bound in enumerate(bounds):
if np.isnan(bound[1]):
const_idx.append(i)
hp_num = len(bounds) - len(const_idx)
es = CMAEvolutionStrategy(hp_num * [0], 0.99, inopts={'bounds': [0, 1], 'seed': seed})
global_start_time = time.time()
global_trial_counter = 0
config_list = []
perf_list = []
time_list = []
eval_num = 0
while eval_num < max_runs:
X = es.ask(number=es.popsize)
_X = X.copy()
for i in range(len(_X)):
for index in const_idx:
_X[i] = np.insert(_X[i], index, 0) # np.insert returns a copy
# _X = np.asarray(_X)
values = []
for xi in _X:
# convert array to Configuration
config = Configuration(cs, vector=xi)
perf = objective_function(config)
global_time = time.time() - global_start_time
global_trial_counter += 1
values.append(perf)
print('=== CMAES Trial %d: %s perf=%f global_time=%f' % (global_trial_counter, config, perf, global_time))
config_list.append(config)
perf_list.append(perf)
time_list.append(global_time)
values = np.reshape(values, (-1,))
es.tell(X, values)
eval_num += es.popsize
print('===== Total evaluation times=%d. Truncate to max_runs=%d.' % (eval_num, max_runs))
config_list = config_list[:max_runs]
perf_list = perf_list[:max_runs]
time_list = time_list[:max_runs]
return config_list, perf_list, time_list
def __init__(self,
objective_function,
config_space,
sample_strategy='bo',
time_limit_per_trial=180,
max_runs=200,
logging_dir='logs',
initial_configurations=None,
initial_batch=1,
batch_size=3,
task_id=None,
rng=None):
super().__init__(config_space, task_id, output_dir=logging_dir)
self.logger = super()._get_logger(self.__class__.__name__)
if rng is None:
run_id, rng = get_rng()
self.batch_size = batch_size
self.init_batch = initial_batch
self.max_iterations = max_runs
self.iteration_id = 0
self.sls_max_steps = None
self.n_sls_iterations = 5
self.sls_n_steps_plateau_walk = 10
self.time_limit_per_trial = time_limit_per_trial
self.default_obj_value = MAXINT
self.sample_strategy = sample_strategy
self.configurations = list()
self.failed_configurations = list()
self.perfs = list()
# Initialize the basic component in BO.
self.config_space.seed(rng.randint(MAXINT))
self.objective_function = objective_function
types, bounds = get_types(config_space)
# TODO: what is the feature array.
self.model = RandomForestWithInstances(types=types,
bounds=bounds,
seed=rng.randint(MAXINT))
if self.sample_strategy == 'local_penalization':
self.acquisition_function = LPEI(self.model)
else:
self.acquisition_function = EI(self.model)
self.optimizer = InterleavedLocalAndRandomSearch(
acquisition_function=self.acquisition_function,
config_space=self.config_space,
rng=np.random.RandomState(seed=rng.randint(MAXINT)),
max_steps=self.sls_max_steps,
n_steps_plateau_walk=self.sls_n_steps_plateau_walk,
n_sls_iterations=self.n_sls_iterations)
self._random_search = RandomSearch(self.acquisition_function,
self.config_space, rng)
self.random_configuration_chooser = ChooserProb(prob=0.25, rng=rng)
def setup_bo_basics(self):
"""
Prepare the basic BO components.
Returns
-------
An optimizer object.
"""
if self.num_objs == 1 or self.acq_type == 'parego':
self.surrogate_model = build_surrogate(
func_str=self.surrogate_type,
config_space=self.config_space,
rng=self.rng,
history_hpo_data=self.history_bo_data)
else: # multi-objectives
self.surrogate_model = [
build_surrogate(func_str=self.surrogate_type,
config_space=self.config_space,
rng=self.rng,
history_hpo_data=self.history_bo_data)
for _ in range(self.num_objs)
]
if self.num_constraints > 0:
self.constraint_models = [
build_surrogate(func_str=self.constraint_surrogate_type,
config_space=self.config_space,
rng=self.rng)
for _ in range(self.num_constraints)
]
if self.acq_type in ['mesmo', 'mesmoc', 'mesmoc2', 'usemo']:
types, bounds = get_types(self.config_space)
self.acquisition_function = build_acq_func(
func_str=self.acq_type,
model=self.surrogate_model,
constraint_models=self.constraint_models,
types=types,
bounds=bounds)
else:
self.acquisition_function = build_acq_func(
func_str=self.acq_type,
model=self.surrogate_model,
constraint_models=self.constraint_models,
ref_point=self.ref_point)
if self.acq_type == 'usemo':
self.acq_optimizer_type = 'usemo_optimizer'
elif self.acq_type.startswith('mesmo'):
self.acq_optimizer_type = 'mesmo_optimizer'
self.optimizer = build_optimizer(func_str=self.acq_optimizer_type,
acq_func=self.acquisition_function,
config_space=self.config_space,
rng=self.rng)
def __init__(
self,
acquisition_function: AbstractAcquisitionFunction,
config_space: ConfigurationSpace,
rand_prob: float = 0.0,
rng: Union[bool, np.random.RandomState] = None,
):
super().__init__(acquisition_function, config_space, rng)
self.random_chooser = ChooserProb(prob=rand_prob, rng=rng)
types, bounds = get_types(self.config_space)
assert all(types == 0)
self.bounds = bounds
def __init__(self,
acquisition_function: AbstractAcquisitionFunction,
config_space: ConfigurationSpace,
rng: Union[bool, np.random.RandomState] = None,
batch_size=None,
rand_prob=0.0):
super().__init__(acquisition_function, config_space, rng)
self.random_chooser = ChooserProb(prob=rand_prob, rng=rng)
if batch_size is None:
types, bounds = get_types(self.config_space)
dim = np.sum(types == 0)
self.batch_size = min(5000, max(2000, 200 * dim))
else:
self.batch_size = batch_size
def maximize(self, runhistory: HistoryContainer, num_points: int,
**kwargs) -> Iterable[Tuple[float, Configuration]]:
try:
from cma import CMAEvolutionStrategy
except ImportError:
raise ImportError("Package cma is not installed!")
types, bounds = get_types(self.config_space)
assert all(types == 0)
# Check Constant Hyperparameter
const_idx = list()
for i, bound in enumerate(bounds):
if np.isnan(bound[1]):
const_idx.append(i)
hp_num = len(bounds) - len(const_idx)
es = CMAEvolutionStrategy(hp_num * [0],
0.99,
inopts={'bounds': [0, 1]})
eval_num = 0
next_configs_by_acq_value = list()
while eval_num < num_points:
X = es.ask(number=es.popsize)
_X = X.copy()
for i in range(len(_X)):
for index in const_idx:
_X[i] = np.insert(_X[i], index, 0)
_X = np.asarray(_X)
values = self.acquisition_function._compute(_X)
values = np.reshape(values, (-1, ))
es.tell(X, values)
next_configs_by_acq_value.extend([(values[i], _X[i])
for i in range(es.popsize)])
eval_num += es.popsize
next_configs_by_acq_value.sort(reverse=True, key=lambda x: x[0])
next_configs_by_acq_value = [_[1] for _ in next_configs_by_acq_value]
next_configs_by_acq_value = [
Configuration(self.config_space, vector=array)
for array in next_configs_by_acq_value
]
challengers = ChallengerList(next_configs_by_acq_value,
self.config_space, self.random_chooser)
self.random_chooser.next_smbo_iteration()
return challengers
def __init__(
self,
acquisition_function: AbstractAcquisitionFunction,
config_space: ConfigurationSpace,
rand_prob: float = 0.0,
rng: Union[bool, np.random.RandomState] = None,
):
super().__init__(acquisition_function, config_space, rng)
self.random_chooser = ChooserProb(prob=rand_prob, rng=rng)
types, bounds = get_types(self.config_space)
assert all(types == 0)
self.bounds = bounds
options = dict(disp=False, maxiter=1000)
self.scipy_config = dict(tol=None, method='L-BFGS-B', options=options)
def __init__(self,
config_space: ConfigurationSpace,
size,
lower_bounds=None,
upper_bounds=None,
random_state=None):
"""
Parameters
----------
config_space : ConfigurationSpace
ConfigurationSpace to do sampling.
size : int N
Number of samples.
lower_bounds : lower bounds in [0, 1] for continuous dimensions (optional)
upper_bounds : upper bounds in [0, 1] for continuous dimensions (optional)
"""
self.config_space = config_space
types, bounds = get_types(config_space)
self.search_dims = []
for i in range(len(types)):
if types[i] == 0 and bounds[i][1] == 1.0: # Integer and float
self.search_dims.append((0.0, 1.0))
elif types[i] > 0: # Categorical
self.search_dims.append(list(range(types[i])))
else:
raise NotImplementedError()
self.size = size
default_lb, default_ub = zip(*bounds)
self.lower_bounds = np.array(
default_lb) if lower_bounds is None else np.clip(
lower_bounds, default_lb, default_ub)
self.upper_bounds = np.array(
default_ub) if upper_bounds is None else np.clip(
upper_bounds, default_lb, default_ub)
self.rng = check_random_state(random_state)
def build_surrogate(func_str='gp',
config_space=None,
rng=None,
history_hpo_data=None):
assert config_space is not None
func_str = func_str.lower()
types, bounds = get_types(config_space)
seed = rng.randint(MAXINT)
if func_str == 'prf':
try:
from openbox.surrogate.base.rf_with_instances import RandomForestWithInstances
return RandomForestWithInstances(types=types,
bounds=bounds,
seed=seed)
except ModuleNotFoundError:
from openbox.surrogate.base.rf_with_instances_sklearn import skRandomForestWithInstances
print(
'[Build Surrogate] Use probabilistic random forest based on scikit-learn. For better performance, '
'please install pyrfr: '
'https://open-box.readthedocs.io/en/latest/installation/install_pyrfr.html'
)
return skRandomForestWithInstances(types=types,
bounds=bounds,
seed=seed)
elif func_str == 'sk_prf':
from openbox.surrogate.base.rf_with_instances_sklearn import skRandomForestWithInstances
return skRandomForestWithInstances(types=types,
bounds=bounds,
seed=seed)
elif func_str == 'lightgbm':
from openbox.surrogate.lightgbm import LightGBM
return LightGBM(config_space, types=types, bounds=bounds, seed=seed)
if func_str == 'random_forest':
from openbox.surrogate.skrf import RandomForestSurrogate
return RandomForestSurrogate(config_space,
types=types,
bounds=bounds,
seed=seed)
elif func_str.startswith('gp'):
from openbox.surrogate.base.build_gp import create_gp_model
return create_gp_model(model_type=func_str,
config_space=config_space,
types=types,
bounds=bounds,
rng=rng)
elif func_str.startswith('mfgpe'):
from openbox.surrogate.tlbo.mfgpe import MFGPE
inner_surrogate_type = 'prf'
return MFGPE(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif func_str.startswith('tlbo'):
print('the current surrogate is', func_str)
if 'rgpe' in func_str:
from openbox.surrogate.tlbo.rgpe import RGPE
inner_surrogate_type = func_str.split('_')[-1]
return RGPE(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif 'sgpr' in func_str:
from openbox.surrogate.tlbo.stacking_gpr import SGPR
inner_surrogate_type = func_str.split('_')[-1]
return SGPR(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
elif 'topov3' in func_str:
from openbox.surrogate.tlbo.topo_variant3 import TOPO_V3
inner_surrogate_type = func_str.split('_')[-1]
return TOPO_V3(config_space,
history_hpo_data,
seed,
surrogate_type=inner_surrogate_type,
num_src_hpo_trial=-1)
else:
raise ValueError('Invalid string %s for tlbo surrogate!' %
func_str)
else:
raise ValueError('Invalid string %s for surrogate!' % func_str)
def __init__(self,
objective_func,
config_space: ConfigurationSpace,
R,
eta=3,
skip_outer_loop=0,
rand_prob=0.3,
use_bohb=False,
init_weight=None,
update_enable=True,
weight_method='rank_loss_p_norm',
fusion_method='idp',
power_num=3,
random_state=1,
method_id='mqAsyncMFES',
restart_needed=True,
time_limit_per_trial=600,
runtime_limit=None,
seed=1,
ip='',
port=13579,
authkey=b'abc'):
super().__init__(objective_func,
config_space,
R,
eta=eta,
skip_outer_loop=skip_outer_loop,
random_state=random_state,
method_id=method_id,
restart_needed=restart_needed,
time_limit_per_trial=time_limit_per_trial,
runtime_limit=runtime_limit,
ip=ip,
port=port,
authkey=authkey)
self.seed = seed
self.last_n_iteration = None
self.use_bohb_strategy = use_bohb
self.update_enable = update_enable
self.fusion_method = fusion_method
# Parameter for weight method `rank_loss_p_norm`.
self.power_num = power_num
# Specify the weight learning method.
self.weight_method = weight_method
self.weight_update_id = 0
self.weight_changed_cnt = 0
if init_weight is None:
init_weight = [1. / self.s_max] * self.s_max + [0.]
assert len(init_weight) == (self.s_max + 1)
self.logger.info("Initialize weight to %s" %
init_weight[:self.s_max + 1])
types, bounds = get_types(config_space)
if not self.use_bohb_strategy:
self.surrogate = RandomForestEnsemble(types, bounds, self.s_max,
self.eta, init_weight,
self.fusion_method)
else:
self.surrogate = RandomForestWithInstances(types,
bounds,
seed=self.seed)
self.acquisition_function = EI(model=self.surrogate)
self.iterate_id = 0
self.iterate_r = list()
self.hist_weights = list()
# Saving evaluation statistics in Hyperband.
self.target_x = dict()
self.target_y = dict()
for index, item in enumerate(
np.logspace(0, self.s_max, self.s_max + 1, base=self.eta)):
r = int(item)
self.iterate_r.append(r)
self.target_x[r] = list()
self.target_y[r] = list()
# BO optimizer settings.
self.history_container = HistoryContainer(task_id=self.method_name)
self.sls_max_steps = None
self.n_sls_iterations = 5
self.sls_n_steps_plateau_walk = 10
self.rng = np.random.RandomState(seed=self.seed)
self.acq_optimizer = InterleavedLocalAndRandomSearch(
acquisition_function=self.acquisition_function,
config_space=self.config_space,
rng=self.rng,
max_steps=self.sls_max_steps,
n_steps_plateau_walk=self.sls_n_steps_plateau_walk,
n_sls_iterations=self.n_sls_iterations,
rand_prob=0.0,
)
self.random_configuration_chooser = ChooserProb(prob=rand_prob,
rng=self.rng)
self.random_check_idx = 0
def update_weight(self):
start_time = time.time()
max_r = self.iterate_r[-1]
incumbent_configs = self.target_x[max_r]
test_x = convert_configurations_to_array(incumbent_configs)
test_y = np.array(self.target_y[max_r], dtype=np.float64)
r_list = self.surrogate.surrogate_r
K = len(r_list)
if len(test_y) >= 3:
# Get previous weights
if self.weight_method == 'rank_loss_p_norm':
preserving_order_p = list()
preserving_order_nums = list()
for i, r in enumerate(r_list):
fold_num = 5
if i != K - 1:
mean, var = self.surrogate.surrogate_container[
r].predict(test_x)
tmp_y = np.reshape(mean, -1)
preorder_num, pair_num = self.calculate_preserving_order_num(
tmp_y, test_y)
preserving_order_p.append(preorder_num / pair_num)
preserving_order_nums.append(preorder_num)
else:
if len(test_y) < 2 * fold_num:
preserving_order_p.append(0)
else:
# 5-fold cross validation.
kfold = KFold(n_splits=fold_num)
cv_pred = np.array([0] * len(test_y))
for train_idx, valid_idx in kfold.split(test_x):
train_configs, train_y = test_x[
train_idx], test_y[train_idx]
valid_configs, valid_y = test_x[
valid_idx], test_y[valid_idx]
types, bounds = get_types(self.config_space)
_surrogate = RandomForestWithInstances(
types=types, bounds=bounds)
_surrogate.train(train_configs, train_y)
pred, _ = _surrogate.predict(valid_configs)
cv_pred[valid_idx] = pred.reshape(-1)
preorder_num, pair_num = self.calculate_preserving_order_num(
cv_pred, test_y)
preserving_order_p.append(preorder_num / pair_num)
preserving_order_nums.append(preorder_num)
trans_order_weight = np.array(preserving_order_p)
power_sum = np.sum(np.power(trans_order_weight,
self.power_num))
new_weights = np.power(trans_order_weight,
self.power_num) / power_sum
elif self.weight_method == 'rank_loss_prob':
# For basic surrogate i=1:K-1.
mean_list, var_list = list(), list()
for i, r in enumerate(r_list[:-1]):
mean, var = self.surrogate.surrogate_container[r].predict(
test_x)
mean_list.append(np.reshape(mean, -1))
var_list.append(np.reshape(var, -1))
sample_num = 100
min_probability_array = [0] * K
for _ in range(sample_num):
order_preseving_nums = list()
# For basic surrogate i=1:K-1.
for idx in range(K - 1):
sampled_y = self.rng.normal(mean_list[idx],
var_list[idx])
_num, _ = self.calculate_preserving_order_num(
sampled_y, test_y)
order_preseving_nums.append(_num)
fold_num = 5
# For basic surrogate i=K. cv
if len(test_y) < 2 * fold_num:
order_preseving_nums.append(0)
else:
# 5-fold cross validation.
kfold = KFold(n_splits=fold_num)
cv_pred = np.array([0] * len(test_y))
for train_idx, valid_idx in kfold.split(test_x):
train_configs, train_y = test_x[train_idx], test_y[
train_idx]
valid_configs, valid_y = test_x[valid_idx], test_y[
valid_idx]
types, bounds = get_types(self.config_space)
_surrogate = RandomForestWithInstances(
types=types, bounds=bounds)
_surrogate.train(train_configs, train_y)
_pred, _var = _surrogate.predict(valid_configs)
sampled_pred = self.rng.normal(
_pred.reshape(-1), _var.reshape(-1))
cv_pred[valid_idx] = sampled_pred
_num, _ = self.calculate_preserving_order_num(
cv_pred, test_y)
order_preseving_nums.append(_num)
max_id = np.argmax(order_preseving_nums)
min_probability_array[max_id] += 1
new_weights = np.array(min_probability_array) / sample_num
else:
raise ValueError('Invalid weight method: %s!' %
self.weight_method)
else:
old_weights = list()
for i, r in enumerate(r_list):
_weight = self.surrogate.surrogate_weight[r]
old_weights.append(_weight)
new_weights = old_weights.copy()
self.logger.info(
'[%s] %d-th Updating weights: %s' %
(self.weight_method, self.weight_changed_cnt, str(new_weights)))
# Assign the weight to each basic surrogate.
for i, r in enumerate(r_list):
self.surrogate.surrogate_weight[r] = new_weights[i]
self.weight_changed_cnt += 1
# Save the weight data.
self.hist_weights.append(new_weights)
dir_path = os.path.join(self.data_directory, 'saved_weights')
file_name = 'mfes_weights_%s.npy' % (self.method_name, )
if not os.path.exists(dir_path):
os.makedirs(dir_path)
np.save(os.path.join(dir_path, file_name),
np.asarray(self.hist_weights))
self.logger.info(
'update_weight() cost %.2fs. new weights are saved to %s' %
(time.time() - start_time, os.path.join(dir_path, file_name)))
def __init__(self, objective_func,
config_space: ConfigurationSpace,
R,
eta=3,
num_iter=10000,
rand_prob=0.3,
init_weight=None, update_enable=True,
weight_method='rank_loss_p_norm', fusion_method='idp',
power_num=3,
random_state=1,
method_id='mqMFES',
restart_needed=True,
time_limit_per_trial=600,
runtime_limit=None,
ip='',
port=13579,
authkey=b'abc',):
max_queue_len = 3 * R # conservative design
super().__init__(objective_func, method_name=method_id,
restart_needed=restart_needed, time_limit_per_trial=time_limit_per_trial,
runtime_limit=runtime_limit,
max_queue_len=max_queue_len, ip=ip, port=port, authkey=authkey)
self.seed = random_state
self.config_space = config_space
self.config_space.seed(self.seed)
self.R = R
self.eta = eta
self.logeta = lambda x: log(x) / log(self.eta)
self.s_max = int(self.logeta(self.R))
self.B = (self.s_max + 1) * self.R
self.num_iter = num_iter
self.update_enable = update_enable
self.fusion_method = fusion_method
# Parameter for weight method `rank_loss_p_norm`.
self.power_num = power_num
# Specify the weight learning method.
self.weight_method = weight_method
self.weight_update_id = 0
self.weight_changed_cnt = 0
if init_weight is None:
init_weight = [0.]
init_weight.extend([1. / self.s_max] * self.s_max)
assert len(init_weight) == (self.s_max + 1)
self.logger.info('Weight method & flag: %s-%s' % (self.weight_method, str(self.update_enable)))
self.logger.info("Initial weight is: %s" % init_weight[:self.s_max + 1])
types, bounds = get_types(config_space)
self.weighted_surrogate = WeightedRandomForestCluster(
types, bounds, self.s_max, self.eta, init_weight, self.fusion_method
)
self.acquisition_function = EI(model=self.weighted_surrogate)
self.incumbent_configs = []
self.incumbent_perfs = []
self.iterate_id = 0
self.iterate_r = []
self.hist_weights = list()
# Saving evaluation statistics in Hyperband.
self.target_x = dict()
self.target_y = dict()
for index, item in enumerate(np.logspace(0, self.s_max, self.s_max + 1, base=self.eta)):
r = int(item)
self.iterate_r.append(r)
self.target_x[r] = []
self.target_y[r] = []
# BO optimizer settings.
self.configs = list()
self.history_container = HistoryContainer(task_id=self.method_name)
self.sls_max_steps = None
self.n_sls_iterations = 5
self.sls_n_steps_plateau_walk = 10
self.rng = np.random.RandomState(seed=self.seed)
self.acq_optimizer = InterleavedLocalAndRandomSearch(
acquisition_function=self.acquisition_function,
config_space=self.config_space,
rng=self.rng,
max_steps=self.sls_max_steps,
n_steps_plateau_walk=self.sls_n_steps_plateau_walk,
n_sls_iterations=self.n_sls_iterations,
rand_prob=0.0,
)
self.random_configuration_chooser = ChooserProb(prob=rand_prob, rng=self.rng)
