def prepareScoring(
self, spaceSpec: typing.Tuple["skopt.space.space.Real",
"skopt.space.space.Integer",
"skopt.space.space.Categorical"]
) -> typing.Tuple[int, str, typing.Tuple["skopt.space.space.Real",
"skopt.space.space.Integer",
"skopt.space.space.Categorical"]]:
from skopt.utils import cook_estimator, normalize_dimensions
normalized = normalize_dimensions(spaceSpec)
base_estimator = cook_estimator(self.__class__.skoptAlgo,
space=normalized,
random_state=None)
optimizer = skopt.Optimizer(
normalized,
base_estimator,
n_initial_points=0,
acq_func=self.acquisitionType,
acq_optimizer=self.acquisitionOptimizerType,
acq_optimizer_kwargs={
"n_points": self.iters,
"n_restarts_optimizer": self.nRestartsOptimizer,
"n_jobs": self.jobs
},
acq_func_kwargs={
"xi": self.chi,
"kappa": self.kappa
})
return (self.iters, "SKOpt (" + self.__class__.skoptAlgo + ")",
optimizer)
def set_optimizer(self, n_iter, opt_seed, acq_func, gp_seed, **kwargs):
self.logger.info('Retrieving model stored at: {}'.format(self.optimizer_path))
try:
optimizer = load(self.optimizer_path)
self.logger.info('Loading model stored at: {}'.format(self.optimizer_path))
finished_iter = np.array(optimizer.yi).shape[0]
if finished_iter == 0:
optimizer = None
self.logger.info('Optimizer did not finish any iterations so setting optimizer to null')
except KeyError:
self.logger.error('Cannot open the file {}'.format(self.optimizer_path))
optimizer = None
except ValueError:
self.logger.error('Cannot open the file {}'.format(self.optimizer_path))
optimizer = None
except FileNotFoundError:
self.logger.error('No such file or directory: {}'.format(self.optimizer_path))
optimizer = None
if optimizer is not None:
n_iter = n_iter - finished_iter
if n_iter < 0:
n_iter = 0
self.logger.info('Iterations already done: {} and running iterations {}'.format(finished_iter, n_iter))
self.opt = optimizer
self.logger.debug('Setting the provided optimizer')
self.log_best_params()
else:
transformed = []
for param in self.parameter_ranges:
transformed.append(check_dimension(param))
self.logger.info("Parameter Space: {}".format(transformed))
norm_space = normalize_dimensions(transformed)
self.logger.info("Parameter Space after transformation: {}".format(norm_space))
categorical_space = np.array([isinstance(s, Categorical) for s in norm_space])
self.logger.info("categorical_space: {}".format(categorical_space))
if np.all(categorical_space):
base_estimator = cook_estimator("RF", space=norm_space, random_state=gp_seed)
else:
base_estimator = cook_estimator("GP", space=norm_space, random_state=gp_seed, noise="gaussian")
self.opt = Optimizer(dimensions=self.parameter_ranges, random_state=opt_seed, base_estimator=base_estimator,
acq_func=acq_func, **kwargs)
return n_iter
def test_acquisition_gradient_cookbook():
rng = np.random.RandomState(0)
X = rng.randn(20, 5)
y = rng.randn(20)
X_new = rng.randn(5)
gpr = cook_estimator("GP", Space(((-5.0, 5.0), )), random_state=0)
gpr.fit(X, y)
for acq_func in ["LCB", "PI", "EI"]:
check_gradient_correctness(X_new, gpr, acq_func, np.max(y))
def test_use_given_estimator():
""" Test that gp_minimize does not use default estimator if one is passed
in explicitly. """
domain = [(1.0, 2.0), (3.0, 4.0)]
noise_correct = 1e+5
noise_fake = 1e-10
estimator = cook_estimator("GP", domain, noise=noise_correct)
res = gp_minimize(branin, domain, n_calls=1, n_random_starts=1,
base_estimator=estimator, noise=noise_fake)
assert res['models'][-1].noise == noise_correct
def test_use_given_estimator():
""" Test that gp_minimize does not use default estimator if one is passed
in explicitly. """
domain = [(1.0, 2.0), (3.0, 4.0)]
noise_correct = 1e+5
noise_fake = 1e-10
estimator = cook_estimator("GP", domain, noise=noise_correct)
res = gp_minimize(branin, domain, n_calls=1, n_random_starts=1,
base_estimator=estimator, noise=noise_fake)
assert res['models'][-1].noise == noise_correct
def test_acquisition_per_second_gradient(acq_func):
rng = np.random.RandomState(0)
X = rng.randn(20, 10)
# Make the second component large, so that mean_grad and std_grad
# do not become zero.
y = np.vstack((X[:, 0], np.abs(X[:, 0])**3)).T
for X_new in [rng.randn(10), rng.randn(10)]:
gpr = cook_estimator("GP", Space(((-5.0, 5.0),)), random_state=0)
mor = MultiOutputRegressor(gpr)
mor.fit(X, y)
check_gradient_correctness(X_new, mor, acq_func, 1.5)
def test_acquisition_per_second_gradient(acq_func):
rng = np.random.RandomState(0)
X = rng.randn(20, 10)
# Make the second component large, so that mean_grad and std_grad
# do not become zero.
y = np.vstack((X[:, 0], np.abs(X[:, 0])**3)).T
for X_new in [rng.randn(10), rng.randn(10)]:
gpr = cook_estimator("GP", Space(((-5.0, 5.0), )), random_state=0)
mor = MultiOutputRegressor(gpr)
mor.fit(X, y)
check_gradient_correctness(X_new, mor, acq_func, 1.5)
def fit(self, X, y):
"""
The first estimator returns a constant value.
The second estimator is a gaussian process regressor that
models the logarithm of the time.
"""
X = np.array(X)
gpr = cook_estimator("GP", self.space, normalize_y=False)
gpr.fit(X, np.log(np.ravel(X)))
self.estimators_ = []
self.estimators_.append(ConstSurrogate())
self.estimators_.append(gpr)
return self
def best_fit_curve(x, y):
from skopt.utils import cook_estimator
from skopt.space import Real
# single feature dataset
X = np.array(x)[:, np.newaxis]
# fit gaussian process model
model = cook_estimator('GP', [Real(0.1, 2.0)])
model.fit(X, y)
fnc = lambda V: model.predict(V[:, np.newaxis])
return fnc
def fit(self, X, y):
"""
The first estimator returns a constant value.
The second estimator is a gaussian process regressor that
models the logarithm of the time.
"""
X = np.array(X)
y = np.array(y)
gpr = cook_estimator("GP", self.space, random_state=0)
gpr.fit(X, np.log(np.ravel(X)))
self.estimators_ = []
self.estimators_.append(ConstSurrogate())
self.estimators_.append(gpr)
return self
def test_use_given_estimator_with_max_model_size():
""" Test that gp_minimize does not use default estimator if one is passed
in explicitly. """
domain = [(1.0, 2.0), (3.0, 4.0)]
noise_correct = 1e+5
noise_fake = 1e-10
estimator = cook_estimator("GP", domain, noise=noise_correct)
res = gp_minimize(branin,
domain,
n_calls=1,
n_initial_points=1,
base_estimator=estimator,
noise=noise_fake,
model_queue_size=1)
assert len(res['models']) == 1
assert res['models'][-1].noise == noise_correct
def create_opt(lines, ranker_name):
gp_seed, opt_seed = get_seed(lines)
_ranker_class = object_rankers[ranker_name]
_ranker_class._use_early_stopping = True
param_ranges = _ranker_class.set_tunable_parameter_ranges({})
transformed = []
for param in param_ranges:
transformed.append(check_dimension(param))
space = normalize_dimensions(transformed)
base_estimator = cook_estimator("GP",
space=space,
random_state=gp_seed,
noise="gaussian")
optimizer = Optimizer(dimensions=param_ranges,
random_state=opt_seed,
base_estimator=base_estimator)
return optimizer
def _proc_optimizer_opts(args_dict):
"""Process optimizer kwargs.
This is meainly used to set different defaults
for skopt.learn - Tree regressors.
"""
from skopt.utils import cook_estimator
if args_dict is None:
return {}
if "base_estimator" in args_dict:
if args_dict["base_estimator"] == "ET":
args = {
"n_estimators": 100,
"min_samples_leaf": 3,
"max_depth": None,
"bootstrap": False
}
elif args_dict["base_estimator"] == "ET2":
args = {
"n_estimators": 1000,
"min_samples_leaf": 1,
"max_depth": None,
"bootstrap": False
}
args_dict["base_estimator"] = "ET"
elif args_dict["base_estimator"] == "RF":
args = {
"n_estimators": 100,
"min_samples_leaf": 1,
"max_depth": None,
"bootstrap": True
}
elif args_dict["base_estimator"] == "GBRT":
args = None
else:
args = None
if args:
args_dict["base_estimator"] = cook_estimator(
args_dict["base_estimator"], **args)
return args_dict
def __init__(self,
dimensions,
base_estimator='gp',
n_random_starts=None,
n_initial_points=10,
acq_func='gp_hedge',
acq_optimizer='auto',
random_state=None,
acq_func_kwargs=None,
acq_optimizer_kwargs=None):
"""This is nearly identical to :meth:`skopt.optimizer.optimizer.Optimizer.__init__`. It is recreated here to use the
modified :class:`hyperparameter_hunter.space.Space`, rather than the original `skopt` version. This is not an ideal
solution, and other options are being considered
Parameters
----------
dimensions: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
base_estimator: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
n_random_starts: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
n_initial_points: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
acq_func: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
acq_optimizer: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
random_state: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
acq_func_kwargs: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`
acq_optimizer_kwargs: See :class:`skopt.optimizer.optimizer.Optimizer.__init__`"""
# TODO: Figure out way to override skopt Optimizer's use of skopt Space without having to rewrite __init__
self.__repeated_ask_kwargs = {}
self.rng = check_random_state(random_state)
# Configure acquisition function - Store and create acquisition function set
self.acq_func = acq_func
self.acq_func_kwargs = acq_func_kwargs
allowed_acq_funcs = ['gp_hedge', 'EI', 'LCB', 'PI', 'EIps', 'PIps']
if self.acq_func not in allowed_acq_funcs:
raise ValueError(
F'Expected `acq_func` to be in {allowed_acq_funcs}, got {self.acq_func}'
)
# Treat hedging method separately
if self.acq_func == 'gp_hedge':
self.cand_acq_funcs_ = ['EI', 'LCB', 'PI']
self.gains_ = np.zeros(3)
else:
self.cand_acq_funcs_ = [self.acq_func]
if acq_func_kwargs is None:
acq_func_kwargs = dict()
self.eta = acq_func_kwargs.get('eta', 1.0)
# Configure counters of points - Check `n_random_starts` deprecation first
if n_random_starts is not None:
warnings.warn((
'`n_random_starts` will be removed in favour of `n_initial_points`'
), DeprecationWarning)
n_initial_points = n_random_starts
if n_initial_points < 0:
raise ValueError(
F'Expected `n_initial_points` >= 0, got {n_initial_points}')
self._n_initial_points = n_initial_points
self.n_initial_points_ = n_initial_points
# Configure estimator - Build `base_estimator` if doesn't exist
if isinstance(base_estimator, str):
base_estimator = cook_estimator(base_estimator,
space=dimensions,
random_state=self.rng.randint(
0,
np.iinfo(np.int32).max))
# Check if regressor
if not is_regressor(base_estimator) and base_estimator is not None:
raise ValueError(
F'`base_estimator`={base_estimator} must be a regressor')
# Treat per second acquisition function specially
is_multi_regressor = isinstance(base_estimator, MultiOutputRegressor)
if 'ps' in self.acq_func and not is_multi_regressor:
self.base_estimator_ = MultiOutputRegressor(base_estimator)
else:
self.base_estimator_ = base_estimator
# Configure optimizer - Decide optimizer based on gradient information
if acq_optimizer == 'auto':
if has_gradients(self.base_estimator_):
acq_optimizer = 'lbfgs'
else:
acq_optimizer = 'sampling'
if acq_optimizer not in ['lbfgs', 'sampling']:
raise ValueError(
'Expected `acq_optimizer` to be "lbfgs" or "sampling", got {}'.
format(acq_optimizer))
if (not has_gradients(self.base_estimator_)
and acq_optimizer != 'sampling'):
raise ValueError(
'The regressor {} should run with `acq_optimizer`="sampling"'.
format(type(base_estimator)))
self.acq_optimizer = acq_optimizer
# Record other arguments
if acq_optimizer_kwargs is None:
acq_optimizer_kwargs = dict()
self.n_points = acq_optimizer_kwargs.get('n_points', 10000)
self.n_restarts_optimizer = acq_optimizer_kwargs.get(
'n_restarts_optimizer', 5)
n_jobs = acq_optimizer_kwargs.get('n_jobs', 1)
self.n_jobs = n_jobs
self.acq_optimizer_kwargs = acq_optimizer_kwargs
# Configure search space - Normalize space if GP regressor
if isinstance(self.base_estimator_, GaussianProcessRegressor):
dimensions = normalize_dimensions(dimensions)
self.space = Space(dimensions)
# Record categorical and non-categorical indices
self._cat_inds = []
self._non_cat_inds = []
for ind, dim in enumerate(self.space.dimensions):
if isinstance(dim, Categorical):
self._cat_inds.append(ind)
else:
self._non_cat_inds.append(ind)
# Initialize storage for optimization
self.models = []
self.Xi = []
self.yi = []
# Initialize cache for `ask` method responses
# This ensures that multiple calls to `ask` with n_points set return same sets of points. Reset to {} at call to `tell`
self.cache_ = {}
def _prepare_estimator(self):
"""Initialize :attr:`base_estimator` with :attr:`space` via `skopt.utils.cook_estimator`"""
self.base_estimator = cook_estimator(
self.base_estimator, space=self.space, **self.base_estimator_kwargs
)
def test_has_gradients(estimator, gradients):
space = Space([(-2.0, 2.0)])
assert has_gradients(cook_estimator(estimator, space=space)) == gradients
def fit(self,
X,
Y,
total_duration=6e7,
n_iter=100,
cv_iter=None,
optimizer=None,
acq_func='gp_hedge',
**kwargs):
start = datetime.now()
def splitter(itr):
for train_idx, test_idx in itr:
yield X[train_idx], Y[train_idx], X[test_idx], Y[test_idx]
def splitter_dict(itr_dict):
n_splits = len(list(itr_dict.values())[0])
for i in range(n_splits):
X_train = dict()
Y_train = dict()
X_test = dict()
Y_test = dict()
for n_obj, itr in itr_dict.items():
train_idx = itr[i][0]
test_idx = itr[i][1]
X_train[n_obj] = np.copy(X[n_obj][train_idx])
X_test[n_obj] = np.copy(X[n_obj][test_idx])
Y_train[n_obj] = np.copy(Y[n_obj][train_idx])
Y_test[n_obj] = np.copy(Y[n_obj][test_idx])
yield X_train, Y_train, X_test, Y_test
if cv_iter is None:
cv_iter = ShuffleSplit(n_splits=3,
test_size=0.1,
random_state=self.random_state)
if isinstance(X, dict):
splits = dict()
for n_obj, arr in X.items():
if arr.shape[0] == 1:
splits[n_obj] = [([0], [0])
for i in range(cv_iter.n_splits)]
else:
splits[n_obj] = list(cv_iter.split(arr))
else:
splits = list(cv_iter.split(X))
# Pre-compute splits for reuse
# Here we fix a random seed for all simulations to correlate the random
# streams:
seed = self.random_state.randint(2**32, dtype='uint32')
self.logger.debug(
'Random seed for the ranking algorithm: {}'.format(seed))
opt_seed = self.random_state.randint(2**32, dtype='uint32')
self.logger.debug('Random seed for the optimizer: {}'.format(opt_seed))
gp_seed = self.random_state.randint(2**32, dtype='uint32')
self.logger.debug(
'Random seed for the GP surrogate: {}'.format(gp_seed))
if optimizer is not None:
opt = optimizer
self.logger.debug('Setting the provided optimizer')
self.log_best_params(opt)
else:
transformed = []
for param in self.parameter_ranges:
transformed.append(check_dimension(param))
self.logger.info("Parameter Space: {}".format(transformed))
space = normalize_dimensions(transformed)
self.logger.info(
"Parameter Space after transformation: {}".format(space))
# Todo: Make this passable
base_estimator = cook_estimator("GP",
space=space,
random_state=gp_seed,
noise="gaussian")
opt = Optimizer(dimensions=self.parameter_ranges,
random_state=opt_seed,
base_estimator=base_estimator,
acq_func=acq_func,
**kwargs)
self._callbacks_set_optimizer(opt)
self._callbacks_on_optimization_begin()
time_taken = duration_tillnow(start)
total_duration -= time_taken
max_fit_duration = -10000
self.logger.info('Time left for {} iterations is {}'.format(
n_iter, microsec_to_time(total_duration)))
try:
for t in range(n_iter):
start = datetime.now()
self._callbacks_on_iteration_begin(t)
self.logger.info(
'Starting optimization iteration: {}'.format(t))
if t > 0:
self.log_best_params(opt)
next_point = opt.ask()
self.logger.info('Next parameters:\n{}'.format(next_point))
results = []
running_times = []
if isinstance(X, dict):
for X_train, Y_train, X_test, Y_test in splitter_dict(
splits):
result, time_taken = self._fit_ranker(
X_train, Y_train, X_test, Y_test, next_point)
running_times.append(time_taken)
results.append(result)
else:
for X_train, Y_train, X_test, Y_test in splitter(splits):
result, time_taken = self._fit_ranker(
X_train, Y_train, X_test, Y_test, next_point)
running_times.append(time_taken)
results.append(result)
results = np.array(results)
running_times = np.array(running_times)
mean_result = np.mean(results)
mean_fitting_duration = np.mean(running_times)
# Storing the maximum time to run the splitting model and adding the time for out of sample evaluation
if max_fit_duration < np.sum(running_times):
max_fit_duration = np.sum(running_times)
self.logger.info(
'Validation error for the parameters is {:.4f}'.format(
mean_result))
self.logger.info('Time taken for the parameters is {}'.format(
microsec_to_time(np.sum(running_times))))
if "ps" in opt.acq_func:
opt.tell(next_point, [mean_result, mean_fitting_duration])
else:
opt.tell(next_point, mean_result)
self._callbacks_on_iteration_end(t)
self.logger.info(
"Main optimizer iterations done {} and saving the model".
format(np.array(opt.yi).shape[0]))
dump(opt, self.optimizer_path)
time_taken = duration_tillnow(start)
total_duration -= time_taken
self.logger.info('Time left for simulations is {} '.format(
microsec_to_time(total_duration)))
if (total_duration - max_fit_duration) < 0:
self.logger.info(
'At iteration {} maximum time required by model to validate a parameter values'
.format(microsec_to_time(max_fit_duration)))
self.logger.info(
'At iteration {} simulation stops, due to time deficiency'
.format(t))
break
except KeyboardInterrupt:
self.logger.debug(
'Optimizer interrupted saving the model at {}'.format(
self.optimizer_path))
self.log_best_params(opt)
else:
self.logger.debug(
'Finally, fit a model on the complete training set and storing the model at {}'
.format(self.optimizer_path))
self._fit_params["epochs"] = self._fit_params.get("epochs", 1000)
if "ps" in opt.acq_func:
best_point = opt.Xi[np.argmin(np.array(opt.yi)[:, 0])]
else:
best_point = opt.Xi[np.argmin(opt.yi)]
self._set_new_parameters(best_point)
self.model = copy.copy(self.ranker)
self.model.fit(X, Y, **self._fit_params)
finally:
self._callbacks_on_optimization_end()
self.optimizer = opt
if np.array(opt.yi).shape[0] != 0:
dump(opt, self.optimizer_path)
def run(self):
"""start the tuning process"""
def objective(var):
"""objective method receive the benchmark result and send the next parameters"""
iter_result = {}
option = []
for i, knob in enumerate(self.knobs):
params[knob['name']] = var[i]
if knob['dtype'] == 'string':
option.append(knob['options'].index(var[i]))
else:
option.append(var[i])
iter_result["param"] = params
self.child_conn.send(iter_result)
result = self.child_conn.recv()
x_num = 0.0
eval_list = result.split(',')
for value in eval_list:
num = float(value)
x_num = x_num + num
options.append(option)
performance.append(x_num)
return x_num
params = {}
options = []
performance = []
labels = []
estimator = None
try:
if self.engine == 'random' or self.engine == 'forest' or \
self.engine == 'gbrt' or self.engine == 'bayes' or self.engine == 'extraTrees':
params_space = self.build_space()
ref_x, ref_y = self.transfer()
if len(ref_x) == 0:
if len(self.ref) == 0:
ref_x = None
else:
ref_x = self.ref
ref_y = None
if ref_x is not None and not isinstance(
ref_x[0], (list, tuple)):
ref_x = [ref_x]
LOGGER.info('x0: %s', ref_x)
LOGGER.info('y0: %s', ref_y)
if ref_x is not None and isinstance(ref_x[0], (list, tuple)):
self._n_random_starts = 0 if len(ref_x) >= self._n_random_starts \
else self._n_random_starts - len(ref_x) + 1
LOGGER.info('n_random_starts parameter is: %d',
self._n_random_starts)
LOGGER.info("Running performance evaluation.......")
if self.engine == 'random':
estimator = 'dummy'
elif self.engine == 'forest':
estimator = 'RF'
elif self.engine == 'extraTrees':
estimator = 'ET'
elif self.engine == 'gbrt':
estimator = 'GBRT'
elif self.engine == 'bayes':
params_space = normalize_dimensions(params_space)
estimator = cook_estimator("GP",
space=params_space,
noise=self.noise)
LOGGER.info("base_estimator is: %s", estimator)
optimizer = baseOpt(dimensions=params_space,
n_random_starts=self._n_random_starts,
random_state=1,
base_estimator=estimator)
n_calls = self.max_eval
# User suggested points at which to evaluate the objective first
if ref_x and ref_y is None:
ref_y = list(map(objective, ref_x))
LOGGER.info("ref_y is: %s", ref_y)
# Pass user suggested initialisation points to the optimizer
if ref_x:
if not isinstance(ref_y,
(collections.Iterable, numbers.Number)):
raise ValueError(
"`ref_y` should be an iterable or a scalar, "
"got %s" % type(ref_y))
if len(ref_x) != len(ref_y):
raise ValueError("`ref_x` and `ref_y` should "
"have the same length")
LOGGER.info("ref_x: %s", ref_x)
LOGGER.info("ref_y: %s", ref_y)
n_calls -= len(ref_y)
ret = optimizer.tell(ref_x, ref_y)
for i in range(n_calls):
next_x = optimizer.ask()
LOGGER.info("next_x: %s", next_x)
LOGGER.info("Running performance evaluation.......")
next_y = objective(next_x)
LOGGER.info("next_y: %s", next_y)
ret = optimizer.tell(next_x, next_y)
LOGGER.info("finish (ref_x, ref_y) tell")
elif self.engine == 'abtest':
abtuning_manager = ABtestTuningManager(self.knobs,
self.child_conn,
self.split_count)
options, performance = abtuning_manager.do_abtest_tuning_abtest(
)
params = abtuning_manager.get_best_params()
# convert string option into index
options = abtuning_manager.get_options_index(options)
elif self.engine == 'gridsearch':
num_done = 0
if self.y_ref is not None:
num_done = len(self.y_ref)
gstuning_manager = GridSearchTuningManager(
self.knobs, self.child_conn)
options, performance = gstuning_manager.do_gridsearch(num_done)
params, labels = gstuning_manager.get_best_params()
# convert string option into index
options = gstuning_manager.get_options_index(options)
elif self.engine == 'lhs':
from analysis.optimizer.knob_sampling_manager import KnobSamplingManager
knobsampling_manager = KnobSamplingManager(
self.knobs, self.child_conn, self.max_eval,
self.split_count)
options = knobsampling_manager.get_knob_samples()
performance = knobsampling_manager.do_knob_sampling_test(
options)
params = knobsampling_manager.get_best_params(
options, performance)
options = knobsampling_manager.get_options_index(options)
elif self.engine == 'tpe':
from analysis.optimizer.tpe_optimizer import TPEOptimizer
tpe_opt = TPEOptimizer(self.knobs, self.child_conn,
self.max_eval)
best_params = tpe_opt.tpe_minimize_tuning()
final_param = {}
final_param["finished"] = True
final_param["param"] = best_params
self.child_conn.send(final_param)
return best_params
elif self.engine == 'traverse':
from analysis.optimizer.knob_traverse_manager import KnobTraverseManager
default_values = [
p_nob['ref'] for _, p_nob in enumerate(self.knobs)
]
knobtraverse_manager = KnobTraverseManager(
self.knobs, self.child_conn, default_values)
traverse_list = knobtraverse_manager.get_traverse_list()
performance = knobtraverse_manager.get_traverse_performance(
traverse_list)
rank = knobtraverse_manager.get_traverse_rank(performance)
final_param = {
"rank": rank,
"param": knobtraverse_manager.get_default_values(),
"finished": True
}
self.child_conn.send(final_param)
return final_param["param"]
LOGGER.info("Minimization procedure has been completed.")
except ValueError as value_error:
LOGGER.error('Value Error: %s', repr(value_error))
self.child_conn.send(value_error)
return None
except RuntimeError as runtime_error:
LOGGER.error('Runtime Error: %s', repr(runtime_error))
self.child_conn.send(runtime_error)
return None
except Exception as err:
LOGGER.error('Unexpected Error: %s', repr(err))
self.child_conn.send(Exception("Unexpected Error:", repr(err)))
return None
for i, knob in enumerate(self.knobs):
if estimator is not None:
params[knob['name']] = ret.x[i]
if self.engine != 'gridsearch':
labels.append(knob['name'])
LOGGER.info("Optimized result: %s", params)
LOGGER.info("The optimized profile has been generated.")
final_param = {}
if self.sel_feature is True:
if self.feature_selector == "wefs":
wefs = WeightedEnsembleFeatureSelector()
rank = wefs.get_ensemble_feature_importance(
options, performance, labels)
elif self.feature_selector == "vrfs":
vrfs = VarianceReductionFeatureSelector()
rank = vrfs.get_ensemble_feature_importance(
options, performance, labels)
final_param["rank"] = rank
LOGGER.info(
"The feature importances of current evaluation are: %s", rank)
final_param["param"] = params
final_param["finished"] = True
self.child_conn.send(final_param)
return params
def _prepare_estimator(self):
"""Initialize :attr:`base_estimator` with :attr:`hyperparameter_space` and any other kwargs, using
`skopt.utils.cook_estimator`"""
self.base_estimator = cook_estimator(self.base_estimator,
space=self.hyperparameter_space,
**self.base_estimator_kwargs)
def test_has_gradients(estimator, gradients):
space = Space([(-2.0, 2.0)])
assert has_gradients(cook_estimator(estimator, space=space)) == gradients
def test_categorical_gp_has_gradients():
space = Space([('a', 'b')])
assert not has_gradients(cook_estimator('GP', space=space))
def test_categorical_gp_has_gradients():
space = Space([('a', 'b')])
assert not has_gradients(cook_estimator('GP', space=space))
