class async_mqMFES(async_mqHyperband):
"""
The implementation of Asynchronous MFES (combine ASHA and MFES)
"""
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_observation(self, config, perf, n_iteration):
rung_id = self.get_rung_id(self.bracket, n_iteration)
updated = False
for job in self.bracket[rung_id]['jobs']:
_job_status, _config, _perf, _extra_conf = job
if _config == config:
assert _job_status == RUNNING
job[0] = COMPLETED
job[2] = perf
updated = True
break
assert updated
# print('=== bracket after update_observation:', self.get_bracket_status(self.bracket))
configs_running = list()
for _config in self.bracket[rung_id]['configs']:
if _config not in self.target_x[n_iteration]:
configs_running.append(_config)
value_imputed = np.median(self.target_y[n_iteration])
n_iteration = int(n_iteration)
self.target_x[n_iteration].append(config)
self.target_y[n_iteration].append(perf)
if n_iteration == self.R:
self.incumbent_configs.append(config)
self.incumbent_perfs.append(perf)
# Update history container.
self.history_container.add(config, perf)
# Refit the ensemble surrogate model.
configs_train = self.target_x[n_iteration] + configs_running
results_train = self.target_y[n_iteration] + [value_imputed
] * len(configs_running)
results_train = np.array(std_normalization(results_train),
dtype=np.float64)
if not self.use_bohb_strategy:
self.surrogate.train(
convert_configurations_to_array(configs_train),
results_train,
r=n_iteration)
else:
if n_iteration == self.R:
self.surrogate.train(
convert_configurations_to_array(configs_train),
results_train)
def choose_next(self):
"""
sample a config according to MFES. give iterations according to Hyperband strategy.
"""
next_config = None
next_n_iteration = self.get_next_n_iteration()
next_rung_id = self.get_rung_id(self.bracket, next_n_iteration)
# Update weight when the inner loop of hyperband is finished
if self.last_n_iteration != next_n_iteration and not self.use_bohb_strategy:
if self.update_enable and self.weight_update_id > self.s_max:
self.update_weight()
self.weight_update_id += 1
self.last_n_iteration = next_n_iteration
# sample config
excluded_configs = self.bracket[next_rung_id]['configs']
if len(self.target_y[self.iterate_r[-1]]) == 0:
next_config = sample_configuration(
self.config_space, excluded_configs=excluded_configs)
else:
# Like BOHB, sample a fixed percentage of random configurations.
self.random_check_idx += 1
if self.random_configuration_chooser.check(self.random_check_idx):
next_config = sample_configuration(
self.config_space, excluded_configs=excluded_configs)
else:
acq_configs = self.get_bo_candidates()
for config in acq_configs:
if config not in self.bracket[next_rung_id]['configs']:
next_config = config
break
if next_config is None:
self.logger.warning(
'Cannot get a non duplicate configuration from bo candidates. '
'Sample a random one.')
next_config = sample_configuration(
self.config_space, excluded_configs=excluded_configs)
next_extra_conf = {}
return next_config, next_n_iteration, next_extra_conf
def get_bo_candidates(self):
std_incumbent_value = np.min(
std_normalization(self.target_y[self.iterate_r[-1]]))
# Update surrogate model in acquisition function.
self.acquisition_function.update(model=self.surrogate,
eta=std_incumbent_value,
num_data=len(self.incumbent_configs))
challengers = self.acq_optimizer.maximize(
runhistory=self.history_container,
num_points=5000,
)
return challengers.challengers
@staticmethod
def calculate_preserving_order_num(y_pred, y_true):
array_size = len(y_pred)
assert len(y_true) == array_size
total_pair_num, order_preserving_num = 0, 0
for idx in range(array_size):
for inner_idx in range(idx + 1, array_size):
if bool(y_true[idx] > y_true[inner_idx]) == bool(
y_pred[idx] > y_pred[inner_idx]):
order_preserving_num += 1
total_pair_num += 1
return order_preserving_num, total_pair_num
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 get_weights(self):
return self.hist_weights
class BayesianOptimization(BaseFacade):
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_runs=3,
task_id='default_task_id',
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.init_num = initial_runs
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))
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 run(self):
while self.iteration_id < self.max_iterations:
self.iterate()
def iterate(self):
if len(self.configurations) == 0:
X = np.array([])
else:
failed_configs = list() if self.max_y is None else self.failed_configurations.copy()
X = convert_configurations_to_array(self.configurations + failed_configs)
failed_perfs = list() if self.max_y is None else [self.max_y] * len(self.failed_configurations)
Y = np.array(self.perfs + failed_perfs, dtype=np.float64)
config = self.choose_next(X, Y)
trial_state = SUCCESS
trial_info = None
if config not in (self.configurations + self.failed_configurations):
# Evaluate this configuration.
try:
args, kwargs = (config,), dict()
timeout_status, _result = time_limit(self.objective_function, self.time_limit_per_trial,
args=args, kwargs=kwargs)
if timeout_status:
raise TimeoutException(
'Timeout: time limit for this evaluation is %.1fs' % self.time_limit_per_trial)
else:
perf = MAXINT if _result is None else _result
except Exception as e:
if isinstance(e, TimeoutException):
trial_state = TIMEOUT
else:
traceback.print_exc(file=sys.stdout)
trial_state = FAILED
perf = MAXINT
trial_info = str(e)
self.logger.error(trial_info)
if trial_state == SUCCESS and perf < MAXINT:
if len(self.configurations) == 0:
self.default_obj_value = perf
self.configurations.append(config)
self.perfs.append(perf)
self.history_container.add(config, perf)
self.perc = np.percentile(self.perfs, self.scale_perc)
self.min_y = np.min(self.perfs)
self.max_y = np.max(self.perfs)
else:
self.failed_configurations.append(config)
else:
self.logger.debug('This configuration has been evaluated! Skip it.')
if config in self.configurations:
config_idx = self.configurations.index(config)
trial_state, perf = SUCCESS, self.perfs[config_idx]
else:
trial_state, perf = FAILED, MAXINT
self.iteration_id += 1
self.logger.info(
'Iteration-%d, objective improvement: %.4f' % (self.iteration_id, max(0, self.default_obj_value - perf)))
return config, trial_state, perf, trial_info
def choose_next(self, X: np.ndarray, Y: np.ndarray):
_config_num = X.shape[0]
if _config_num < self.init_num:
default_config = self.config_space.get_default_configuration()
if default_config not in (self.configurations + self.failed_configurations):
return default_config
else:
return self._random_search.maximize(runhistory=self.history_container, num_points=1)[0]
if self.sample_strategy == 'random':
return self.sample_config()
elif self.sample_strategy == 'bo':
if self.random_configuration_chooser.check(self.iteration_id):
return self.sample_config()
else:
self.model.train(X, Y)
incumbent_value = self.history_container.get_incumbents()[0][1]
self.acquisition_function.update(model=self.model, eta=incumbent_value,
num_data=len(self.history_container.data))
challengers = self.optimizer.maximize(
runhistory=self.history_container,
num_points=5000,
random_configuration_chooser=self.random_configuration_chooser
)
return challengers.challengers[0]
else:
raise ValueError('Invalid sampling strategy - %s.' % self.sample_strategy)
def sample_config(self):
config = None
_sample_cnt, _sample_limit = 0, 10000
while True:
_sample_cnt += 1
config = self.config_space.sample_configuration()
if config not in (self.configurations + self.failed_configurations):
break
if _sample_cnt >= _sample_limit:
config = self.config_space.sample_configuration()
break
return config
class mqMFES(mqBaseFacade):
"""
MFES-HB: https://arxiv.org/abs/2012.03011
"""
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)
def iterate(self, skip_last=0):
for s in reversed(range(self.s_max + 1)):
if self.update_enable and self.weight_update_id > self.s_max:
self.update_weight()
self.weight_update_id += 1
# Set initial number of configurations
n = int(ceil(self.B / self.R / (s + 1) * self.eta ** s))
# initial number of iterations per config
r = int(self.R * self.eta ** (-s))
# Choose a batch of configurations in different mechanisms.
start_time = time.time()
T = self.choose_next(n)
time_elapsed = time.time() - start_time
self.logger.info("[%s] Choosing next configurations took %.2f sec." % (self.method_name, time_elapsed))
extra_info = None
last_run_num = None
for i in range((s + 1) - int(skip_last)): # changed from s + 1
# Run each of the n configs for <iterations>
# and keep best (n_configs / eta) configurations
n_configs = n * self.eta ** (-i)
n_iteration = r * self.eta ** (i)
n_iter = n_iteration
if last_run_num is not None and not self.restart_needed:
n_iter -= last_run_num
last_run_num = n_iteration
self.logger.info("%s: %d configurations x %d iterations each" %
(self.method_name, int(n_configs), int(n_iteration)))
ret_val, early_stops = self.run_in_parallel(T, n_iter, extra_info)
val_losses = [item['loss'] for item in ret_val]
ref_list = [item['ref_id'] for item in ret_val]
self.target_x[int(n_iteration)].extend(T)
self.target_y[int(n_iteration)].extend(val_losses)
if int(n_iteration) == self.R:
self.incumbent_configs.extend(T)
self.incumbent_perfs.extend(val_losses)
# Update history container.
for _config, _perf in zip(T, val_losses):
self.history_container.add(_config, _perf)
# Select a number of best configurations for the next loop.
# Filter out early stops, if any.
indices = np.argsort(val_losses)
if len(T) == sum(early_stops):
break
if len(T) >= self.eta:
indices = [i for i in indices if not early_stops[i]]
T = [T[i] for i in indices]
extra_info = [ref_list[i] for i in indices]
reduced_num = int(n_configs / self.eta)
T = T[0:reduced_num]
extra_info = extra_info[0:reduced_num]
else:
T = [T[indices[0]]] # todo: confirm no filter early stops?
extra_info = [ref_list[indices[0]]]
val_losses = [val_losses[i] for i in indices][0:len(T)] # update: sorted
incumbent_loss = val_losses[0]
self.add_stage_history(self.stage_id, min(self.global_incumbent, incumbent_loss))
self.stage_id += 1
# self.remove_immediate_model()
for item in self.iterate_r[self.iterate_r.index(r):]:
# NORMALIZE Objective value: normalization
normalized_y = std_normalization(self.target_y[item])
self.weighted_surrogate.train(convert_configurations_to_array(self.target_x[item]),
np.array(normalized_y, dtype=np.float64), r=item)
def run(self, skip_last=0):
try:
for iter in range(1, 1 + self.num_iter):
self.logger.info('-' * 50)
self.logger.info("%s algorithm: %d/%d iteration starts" % (self.method_name, iter, self.num_iter))
start_time = time.time()
self.iterate(skip_last=skip_last)
time_elapsed = (time.time() - start_time) / 60
self.logger.info("%d/%d-Iteration took %.2f min." % (iter, self.num_iter, time_elapsed))
self.iterate_id += 1
self.save_intemediate_statistics()
except Exception as e:
print(e)
self.logger.error(str(e))
# Clean the immediate results.
# self.remove_immediate_model()
def get_bo_candidates(self, num_configs):
# todo: parallel methods
std_incumbent_value = np.min(std_normalization(self.target_y[self.iterate_r[-1]]))
# Update surrogate model in acquisition function.
self.acquisition_function.update(model=self.weighted_surrogate, eta=std_incumbent_value,
num_data=len(self.history_container.data))
challengers = self.acq_optimizer.maximize(
runhistory=self.history_container,
num_points=5000,
)
return challengers.challengers[:num_configs]
def choose_next(self, num_config):
if len(self.target_y[self.iterate_r[-1]]) == 0:
configs = sample_configurations(self.config_space, num_config)
self.configs.extend(configs)
return configs
config_candidates = list()
acq_configs = self.get_bo_candidates(num_configs=2 * num_config)
acq_idx = 0
for idx in range(1, 1 + 2 * num_config):
# Like BOHB, sample a fixed percentage of random configurations.
if self.random_configuration_chooser.check(idx):
_config = self.config_space.sample_configuration()
else:
_config = acq_configs[acq_idx]
acq_idx += 1
if _config not in config_candidates:
config_candidates.append(_config)
if len(config_candidates) >= num_config:
break
if len(config_candidates) < num_config:
config_candidates = expand_configurations(config_candidates, self.config_space, num_config)
_config_candidates = []
for config in config_candidates:
if config not in self.configs: # Check if evaluated
_config_candidates.append(config)
self.configs.extend(_config_candidates)
return _config_candidates
@staticmethod
def calculate_ranking_loss(y_pred, y_true):
length = len(y_pred)
y_pred = np.reshape(y_pred, -1)
y_pred1 = np.tile(y_pred, (length, 1))
y_pred2 = np.transpose(y_pred1)
diff = y_pred1 - y_pred2
y_true = np.reshape(y_true, -1)
y_true1 = np.tile(y_true, (length, 1))
y_true2 = np.transpose(y_true1)
y_mask = (y_true1 - y_true2 > 0) + 0
loss = np.sum(np.log(1 + np.exp(-diff)) * y_mask) / length
return loss
@staticmethod
def calculate_preserving_order_num(y_pred, y_true):
array_size = len(y_pred)
assert len(y_true) == array_size
total_pair_num, order_preserving_num = 0, 0
for idx in range(array_size):
for inner_idx in range(idx + 1, array_size):
if bool(y_true[idx] > y_true[inner_idx]) == bool(y_pred[idx] > y_pred[inner_idx]):
order_preserving_num += 1
total_pair_num += 1
return order_preserving_num, total_pair_num
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.weighted_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.weighted_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.weighted_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.weighted_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.weighted_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 get_incumbent(self, num_inc=1):
assert (len(self.incumbent_perfs) == len(self.incumbent_configs))
indices = np.argsort(self.incumbent_perfs)
configs = [self.incumbent_configs[i] for i in indices[0:num_inc]]
perfs = [self.incumbent_perfs[i] for i in indices[0: num_inc]]
return configs, perfs
def get_weights(self):
return self.hist_weights