Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_run(self):
'''
running some simple algo in aclib 2.0 style
'''
scen = Scenario(scenario={'cs': ConfigurationSpace(),
'run_obj': 'quality',
'output_dir': ''}, cmd_options=None)
stats = Stats(scen)
eta = ExecuteTARunHydra(
cost_oracle=self.oracle, tae=ExecuteTARunAClib,
ta=shlex.split("python test/test_tae/dummy_ta_wrapper_aclib.py 1"),
stats=stats)
status, cost, runtime, ar_info = eta.run(config={}, instance=None, cutoff=10)
assert status == StatusType.SUCCESS
assert cost == 0
assert runtime == 0
print(status, cost, runtime)
eta = ExecuteTARunHydra(cost_oracle=self.oracle, tae=ExecuteTARunAClib,
def get_rf(n_dimensions, rs):
bounds = [(0., 1.) for _ in range(n_dimensions)]
types = np.zeros(n_dimensions)
configspace = smac.configspace.ConfigurationSpace()
for i in range(n_dimensions):
configspace.add_hyperparameter(smac.configspace.UniformFloatHyperparameter('x%d' % i, 0, 1))
model = RandomForestWithInstancesHPO(
configspace=configspace, types=types, bounds=bounds, log_y=False, bootstrap=False, n_iters=5, n_splits=5, seed=1,
)
return model
def test_start_tae_return_abort(self, test_run):
'''
testing abort
'''
# Patch run-function for custom-return
test_run.return_value = StatusType.ABORT, 12345.0, 1.2345, {}
scen = Scenario(scenario={'cs': ConfigurationSpace(),
'run_obj': 'quality',
'output_dir': ''}, cmd_options=None)
stats = Stats(scen)
stats.start_timing()
eta = ExecuteTARun(ta=lambda *args: None, stats=stats)
self.assertRaises(
TAEAbortException, eta.start, config={}, instance=1)
@unittest.mock.patch.object(ConfigurationSpace, 'sample_configuration')
def test_get_next_by_random_search_sorted(self,
patch_sample,
patch_ei,
patch_impute):
values = (10, 1, 9, 2, 8, 3, 7, 4, 6, 5)
patch_sample.return_value = [ConfigurationMock(i) for i in values]
patch_ei.return_value = np.array([[_] for _ in values], dtype=float)
patch_impute.side_effect = lambda l: values
cs = ConfigurationSpace()
ei = EI(None)
rs = RandomSearch(ei, cs)
rval = rs._maximize(
runhistory=None, stats=None, num_points=10, _sorted=True
)
self.assertEqual(len(rval), 10)
for i in range(10):
exp_kernel = Matern(
np.ones([n_dimensions]),
[(np.exp(-10), np.exp(2)) for _ in range(n_dimensions)],
nu=2.5,
)
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
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 = GaussianProcess(
configspace=configspace,
bounds=bounds,
types=types,
kernel=kernel,
seed=rs.randint(low=1, high=10000),
normalize_y=normalize_y,
n_opt_restarts=2,
)
return model
)
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,
)
random_state=seed)
# returns the cross validation accuracy
cv = StratifiedKFold(n_splits=5, random_state=seed) # to make CV splits consistent
score = cross_val_score(mlp, digits.data, digits.target, cv=cv, error_score='raise')
return 1 - np.mean(score) # Because minimize!
logger = logging.getLogger("MLP-example")
logging.basicConfig(level=logging.INFO)
# Build Configuration Space which defines all parameters and their ranges.
# To illustrate different parameter types,
# we use continuous, integer and categorical parameters.
cs = ConfigurationSpace()
# We can add multiple hyperparameters at once:
n_layer = UniformIntegerHyperparameter("n_layer", 1, 5, default_value=1)
n_neurons = UniformIntegerHyperparameter("n_neurons", 8, 1024, log=True, default_value=10)
activation = CategoricalHyperparameter("activation", ['logistic', 'tanh', 'relu'],
default_value='tanh')
solver = CategoricalHyperparameter('solver', ['lbfgs', 'sgd', 'adam'], default_value='adam')
batch_size = UniformIntegerHyperparameter('batch_size', 30, 300, default_value=200)
learning_rate = CategoricalHyperparameter('learning_rate', ['constant', 'invscaling', 'adaptive'],
default_value='constant')
learning_rate_init = UniformFloatHyperparameter('learning_rate_init', 0.0001, 1.0, default_value=0.001, log=True)
cs.add_hyperparameters([n_layer, n_neurons, activation, solver, batch_size, learning_rate, learning_rate_init])
# Adding conditions to restrict the hyperparameter space
# Since learning rate is used when solver is 'sgd'
use_lr = CS.conditions.EqualsCondition(child=learning_rate, parent=solver, value='sgd')
Arguments passed to the optimizer class
See ~smac.facade.smac_facade.SMAC
Returns
-------
x : list
Estimated position of the minimum.
f : float
Value of `func` at the minimum.
s : :class:`smac.facade.smac_facade.SMAC`
SMAC objects which enables the user to get
e.g., the trajectory and runhistory.
"""
# create configuration space
cs = ConfigurationSpace()
# Adjust zero padding
tmplt = 'x{0:0' + str(len(str(len(bounds)))) + 'd}'
for idx, (lower_bound, upper_bound) in enumerate(bounds):
parameter = UniformFloatHyperparameter(name=tmplt.format(idx + 1),
lower=lower_bound,
upper=upper_bound,
default_value=x0[idx])
cs.add_hyperparameter(parameter)
# Create target algorithm runner
ta = ExecuteTAFuncArray(ta=func)
# create scenario
scenario_dict = {
def set_configuration_space(self):
self.configuration_space = ConfigurationSpace()
print("task_type = ", self.task_type)
if self.task_type == "common_classification":
learner_list = ML_LEARNERS
elif self.task_type == "image_classification":
learner_list = CNN_LEARNERS
elif self.task_type == "text_classification":
learner_list = RNN_LEARNERS
else:
learner_list = REGRESSION_LEARNERS
print("learner_list = ", learner_list)
model_type = CategoricalHyperparameter("model_type", learner_list, default_value=learner_list[0])
self.configuration_space.add_hyperparameter(model_type)
if self.task_type == "common_classification":
# self.set_logistic_space(model_type)
self.set_randomforest_space(model_type)
def prepare(self, pipeline_elements: list, maximize_metric: bool):
self.hyperparameter_list = []
# build space
self.space = ConfigurationSpace()
for element in pipeline_elements:
# check if Switch object
if isinstance(element, Switch):
algorithm_options = {} # mapping algorithm name with their child hyper params
for algo in element.elements:
algo_params = [] # hyper params corresponding to "algo"
for name, value in algo.hyperparameters.items():
smac_param = self._convert_PHOTON_to_smac_space(value, (
element.name + "__" + name)) # or element.name__algo.name__name ???
algo_params.append(smac_param)
algorithm_options[(element.name + "__" + algo.name)] = algo_params
algos = CategoricalHyperparameter(name=element.name + "__algos", choices=algorithm_options.keys())