def test_get_best_result_sample_lower():
parameters = [sherpa.Choice('a', [0, 1]),
sherpa.Choice('b', [3, 4])]
results_df = pandas.DataFrame(collections.OrderedDict(
[('Trial-ID', list(range(1, 13))),
('Status', [sherpa.TrialStatus.COMPLETED] * 12),
('stage', [1] * 8 + [2] * 4),
('a', [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]),
('b', [3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 4, 4]),
('Objective', [1., 1.1, 2.1, 2.2, 5., 5.1, 6., 6.1, 1., 1.1, 2.1, 2.2])]
))
rs = sherpa.algorithms.RandomSearch()
gs = SequentialTesting(algorithm=rs,
K=4,
n=(3, 6, 9),
P=0.5,
sample_best=True)
s = set()
for _ in range(20):
best_config = gs.get_best_result(parameters, results_df,
lower_is_better=True)
s.add(tuple(sorted(best_config.items())))
# check that over 20 tries each config gets sampled at least once
assert len(s) == 2
def test_repeat_grid_search():
parameters = [sherpa.Choice('a', [1, 2]),
sherpa.Choice('b', ['a', 'b'])]
alg = sherpa.algorithms.GridSearch()
alg = sherpa.algorithms.Repeat(algorithm=alg, num_times=3)
suggestion = alg.get_suggestion(parameters)
seen = list()
while suggestion != sherpa.AlgorithmState.DONE:
seen.append((suggestion['a'], suggestion['b']))
suggestion = alg.get_suggestion(parameters)
expected_params = [(1, 'a'),
(1, 'b'),
(2, 'a'),
(2, 'b')]
expected = list(itertools.chain.from_iterable(
itertools.repeat(x, 3) for x in expected_params))
print(sorted(expected))
print(sorted(seen))
assert sorted(expected) == sorted(seen)
def test_prep_df_for_linreg():
parameters = [sherpa.Choice('a', [0, 1]),
sherpa.Choice('b', [3, 4])]
configs = [{'a': 0, 'b': 3}, {'a': 0, 'b': 4}]
results_df = pandas.DataFrame(collections.OrderedDict(
[('Trial-ID', list(range(1, 9))),
('Status', [sherpa.TrialStatus.COMPLETED] * 8),
('stage', [1] * 8),
('a', [0, 0, 0, 0, 1, 1, 1, 1]),
('b', [3, 3, 4, 4, 3, 3, 4, 4]),
('Objective', [1., 1.1, 2., 2.1, 5., 5.1, 6., 6.1])]
))
rs = sherpa.algorithms.RandomSearch()
gs = SequentialTesting(algorithm=rs,
K=4,
n=(3, 6, 9),
P=0.5)
r = gs._prep_df_for_linreg(parameters, results_df, configs, lower_is_better=True)
cols = sorted(r.columns.tolist())
r_expected = results_df.loc[results_df.Objective < 5.]
r_expected = r_expected.assign(Rank=pandas.Series([1, 1, 2, 2]))
print(r)
print(r_expected)
assert r.loc[:, cols].equals(r_expected.loc[:, cols])
def test_get_best_configs_larger_is_better():
parameters = [sherpa.Choice('a', [0, 1]),
sherpa.Choice('b', [3, 4])]
configs = [{'a': 0, 'b': 3},
{'a': 0, 'b': 4},
{'a': 1, 'b': 3},
{'a': 1, 'b': 4}]
results_df = pandas.DataFrame(collections.OrderedDict(
[('Trial-ID', list(range(1, 9))),
('Status', [sherpa.TrialStatus.COMPLETED] * 8),
('stage', [1] * 8),
('a', [0, 0, 0, 0, 1, 1, 1, 1]),
('b', [3, 3, 4, 4, 3, 3, 4, 4]),
('Objective', [1., 1.1, 1.1, 1.2, 6., 6.1, 6., 6.1])]
))
rs = sherpa.algorithms.RandomSearch()
gs = SequentialTesting(algorithm=rs,
K=4,
n=(3, 6, 9),
P=0.5)
best_configs = gs._get_best_configs(parameters, results_df, configs,
lower_is_better=False,
alpha=0.05)
print(best_configs)
print(configs[2:])
assert best_configs == configs[2:]
def test_optimize_mix():
# Test a mixture of these
parameters = [
sherpa.Continuous('continuous', [
0.,
1,
]),
sherpa.Choice('choice', [1, 2, 3, 4]),
sherpa.Choice('choice2', [1, 2, 3]),
sherpa.Discrete('discrete', [0, 100])
]
# Function should have maximum: [0.5, 0, 0, 0, 1, 0, 0, 1, 0.5]
# Maximum should be 7
def fun(x):
cont = -1. * (x[0] - 0.5)**2
ch = np.dot(x[1:5], np.array([1, 2, 3, 4]))
ch2 = np.dot(x[5:8], np.array([1, 2, 3]))
discr = -1. * (x[-1] - 0.5)**2
return cont + ch + ch2 + discr
bayesian_optimization = BayesianOptimization()
bayesian_optimization.num_candidates = 100
candidates = bayesian_optimization._generate_candidates(parameters)
X = bayesian_optimization._to_design(candidates, parameters)
Xoptimized, fun_values = bayesian_optimization._maximize(X, fun)
# print(Xoptimized)
# print(fun_values)
print(Xoptimized[fun_values.argmax()])
print(fun_values.max())
assert np.all(
np.isclose(Xoptimized[fun_values.argmax()],
np.array([0.5, 0., 0., 0., 1., 0., 0., 1., 0.5])))
def test_grid_search_repeat():
parameters = [
sherpa.Choice('a', [1, 2]),
sherpa.Choice('b', ['a', 'b']),
sherpa.Continuous('c', [1, 4])
]
alg = sherpa.algorithms.GridSearch(repeat=3)
suggestion = alg.get_suggestion(parameters)
seen = list()
while suggestion:
seen.append((suggestion['a'], suggestion['b'], suggestion['c']))
suggestion = alg.get_suggestion(parameters)
expected_params = [(1, 'a', 2.0), (1, 'a', 3.0), (1, 'b', 2.0),
(1, 'b', 3.0), (2, 'a', 2.0), (2, 'a', 3.0),
(2, 'b', 2.0), (2, 'b', 3.0)]
expected = list(
itertools.chain.from_iterable(
itertools.repeat(x, 3) for x in expected_params))
print(sorted(expected))
print(sorted(seen))
assert sorted(expected) == sorted(seen)
def get_sherpa_parameter(self, name, good_values_only=False):
if good_values_only:
return sherpa.Choice(name=name, range=self.good_values)
elif self.is_categorical:
return sherpa.Choice(name=name, range=self.categories)
elif self.type == int:
return sherpa.Discrete(name=name,
range=self.range,
scale='log' if self.log_scale else 'linear')
else:
return sherpa.Continuous(
name=name,
range=self.range,
scale='log' if self.log_scale else 'linear')
def test_random_search():
parameters = [
sherpa.Continuous('a', [0, 1]),
sherpa.Choice('b', ['x', 'y', 'z'])
]
rs = sherpa.algorithms.RandomSearch(max_num_trials=10, repeat=10)
config_repeat = {}
for i in range(10):
config = rs.get_suggestion(parameters=parameters)
assert config != config_repeat
for j in range(9):
config_repeat = rs.get_suggestion(parameters=parameters)
assert config == config_repeat
assert rs.get_suggestion(parameters=parameters) is None
rs = sherpa.algorithms.RandomSearch(max_num_trials=10, repeat=1)
last_config = {}
for i in range(10):
config = rs.get_suggestion(parameters=parameters)
assert config != last_config
last_config = config
assert rs.get_suggestion(parameters=parameters) is None
rs = sherpa.algorithms.RandomSearch()
last_config = {}
for _ in range(1000):
config = rs.get_suggestion(parameters=parameters)
assert config != last_config
last_config = config
def test_design():
parameters = [
sherpa.Choice('choice', ['a', 'b', 'c', 'd']),
sherpa.Continuous('continuous', [0., 0.4]),
sherpa.Discrete('discrete', [0, 12])
]
bayesian_optimization = BayesianOptimization()
bayesian_optimization.num_candidates = 100
candidates = bayesian_optimization._generate_candidates(parameters)
assert len(candidates) == bayesian_optimization.num_candidates
assert len(candidates.columns) == len(parameters)
X = bayesian_optimization._to_design(candidates, parameters)
assert X.shape == (bayesian_optimization.num_candidates, 6)
for j in range(X.shape[1]):
assert (X[:, j] >= 0.).all() and (X[:, j] <= 1.).all()
df = bayesian_optimization._from_design(X)
pd.testing.assert_frame_equal(df, candidates)
row = bayesian_optimization._from_design(X[0])
row_dict = row.iloc[0].to_dict()
candidates_dict = candidates.iloc[0].to_dict()
assert row_dict['choice'] == candidates_dict['choice']
assert row_dict['discrete'] == candidates_dict['discrete']
assert np.isclose(row_dict['continuous'], candidates_dict['continuous'])
def test_user_code_fails(test_dir):
tempdir = test_dir
parameters = [
sherpa.Choice(name="param_a", range=[1, 2, 3]),
sherpa.Continuous(name="param_b", range=[0, 1])
]
algorithm = sherpa.algorithms.RandomSearch(max_num_trials=3)
db_port = 27000
scheduler = sherpa.schedulers.LocalScheduler()
filename = os.path.join(tempdir, "test.py")
with open(filename, 'w') as f:
f.write(testscript2)
with pytest.warns(RuntimeWarning):
results = sherpa.optimize(filename=filename,
lower_is_better=True,
algorithm=algorithm,
parameters=parameters,
output_dir=tempdir,
scheduler=scheduler,
max_concurrent=1,
db_port=db_port)
class TestLocalSearch:
@pytest.mark.parametrize("parameter,seed,expected",
[(sherpa.Ordinal('p', [0, 1, 2, 3, 4]), {'p': 2}, [1, 3]),
(sherpa.Continuous('p', [0, 1]), {'p': 0.5}, [0.5*0.8, 0.5*1.2]),
(sherpa.Discrete('p', [0, 10]), {'p': 5}, [4, 6]),
(sherpa.Choice('p', [0, 1, 2, 3, 4]), {'p': 2}, [0, 1, 3, 4])])
def test_seed_and_first_suggestion(self, parameter, seed, expected):
study = get_local_search_study_lower_is_better([parameter],
seed)
trial = study.get_suggestion()
assert trial.parameters['p'] == seed['p']
study.add_observation(trial, objective=trial.parameters['p'], iteration=1)
study.finalize(trial)
trial = study.get_suggestion()
assert trial.parameters['p'] in expected
@pytest.mark.parametrize("parameter,seed,expected",
[(sherpa.Ordinal('p', [0, 1, 2, 3, 4]), {'p': 2}, [0, 1]),
(sherpa.Continuous('p', [0, 1]), {'p': 0.5}, [0.5*(0.8), 0.5*(0.8)**2]),
(sherpa.Discrete('p', [0, 10]), {'p': 5}, [int(5*(0.8)), int(5*(0.8)**2)]),
(sherpa.Choice('p', [0, 1, 2]), {'p': 2}, [0])])
def test_expected_value_after_three_iterations(self, parameter, seed, expected):
study = get_local_search_study_lower_is_better([parameter],
seed)
for trial in study:
study.add_observation(trial, objective=trial.parameters['p'], iteration=1)
study.finalize(trial)
if trial.id == 3:
break
assert study.get_best_result()['Objective'] in expected
@pytest.mark.parametrize("param1,seed1,param2,seed2", [(sherpa.Ordinal('p1', [0, 1, 2, 3, 4]), {'p1': 2},
sherpa.Continuous('p2', [0, 1]), {'p2': 0.5})])
def test_only_one_parameter_is_perturbed_at_a_time(self, param1, seed1, param2, seed2):
seed = dict(seed1, **seed2)
study = get_local_search_study_lower_is_better([param1, param2],
seed=seed)
trial = study.get_suggestion()
study.add_observation(trial, objective=1, iteration=1)
study.finalize(trial)
trial = study.get_suggestion()
assert not all(
param_value != seed[param_name] for param_name, param_value in
trial.parameters.items())
def test_mixed_dtype():
algorithm = GPyOpt(max_num_trials=4)
parameters = [
sherpa.Choice('param_int', [0, 1]),
sherpa.Choice('param_float', [0.1, 1.1]),
]
study = sherpa.Study(
parameters=parameters,
algorithm=algorithm,
lower_is_better=True,
disable_dashboard=True,
)
for trial in study:
study.add_observation(trial, iteration=0, objective=0)
study.finalize(trial)
assert type(trial.parameters['param_int']) == int
assert type(trial.parameters['param_float']) == float
def parameters():
parameters = [
sherpa.Continuous('dropout', [0., 0.5]),
sherpa.Continuous('lr', [1e-7, 1e-1], 'log'),
sherpa.Choice('activation', ['relu', 'tanh', 'sigmoid']),
sherpa.Discrete('num_hidden', [100, 300])
]
return parameters
def test_grid_search():
parameters = [
sherpa.Choice('a', [1, 2]),
sherpa.Choice('b', ['a', 'b']),
sherpa.Continuous('c', [1, 4])
]
alg = sherpa.algorithms.GridSearch()
suggestion = alg.get_suggestion(parameters)
seen = set()
while suggestion:
seen.add((suggestion['a'], suggestion['b'], suggestion['c']))
suggestion = alg.get_suggestion(parameters)
assert seen == {(1, 'a', 2.0), (1, 'a', 3.0), (1, 'b', 2.0), (1, 'b', 3.0),
(2, 'a', 2.0), (2, 'a', 3.0), (2, 'b', 2.0), (2, 'b', 3.0)}
def build_sherpa_augmentations_space():
params = [
sherpa.Continuous(name='width_shift', range=[0.0, 0.2]),
sherpa.Continuous(name='height_shift', range=[0.0, 0.2]),
sherpa.Continuous(name='zoom', range=[0.0, 0.3]),
sherpa.Choice(name='horizontal_flip', range=[False, True]),
sherpa.Discrete(name='rotation', range=[0, 30])
]
return params
def test_strip_add_choice():
parameters = [sherpa.Choice('choice', ['a', 'b', 'c', 'd']),
sherpa.Continuous('continuous', [0., 0.4]),
sherpa.Choice('choice2', [1, 2, 3]),
sherpa.Discrete('discrete', [0, 12])]
bayesian_optimization = BayesianOptimization()
bayesian_optimization.num_candidates = 5
candidates = bayesian_optimization._generate_candidates(parameters)
X = bayesian_optimization._to_design(candidates, parameters)
for i, row in enumerate(X):
print(row)
x, args = bayesian_optimization._strip_choice(row)
# print("x: ", x)
# print("args: ", args)
new_row = bayesian_optimization._add_choice(x, *args)
print(new_row)
assert np.all(row == new_row)
def parameter_mask_setter(parameters, parameter_class):
'''
creates a optimizable mask for a given parameter
:param parameters:
:param parameter_class:
:return:
'''
type_sufix = parameter_class_sufix_mapper(parameter_class)
return {
parameter: sherpa.Choice(parameter + type_sufix, [True, False])
for parameter in parameters
}
def get_mock_study():
mock_algorithm = mock.MagicMock()
mock_algorithm.get_suggestion.return_value = {'a': 1, 'b': 2}
mock_stopping_rule = mock.MagicMock()
return sherpa.Study(parameters=[
sherpa.Discrete('a', [1, 2]),
sherpa.Choice('b', [2, 5, 7])
],
algorithm=mock_algorithm,
stopping_rule=mock_stopping_rule,
lower_is_better=True,
disable_dashboard=True)
def build_sherpa_parameter_space():
params = [
sherpa.Ordinal(name='depth', range=[2,3]),
sherpa.Discrete(name='dense_neurons', range=[100, 164]),
sherpa.Discrete(name='init_filters', range=[8,32]),
sherpa.Choice(name='use_batchnorm', range=[False, True]),
sherpa.Continuous(name='dropout', range=[0.35, 0.55]),
sherpa.Ordinal(name='batch_size', range=[512, 1024]),
sherpa.Continuous(name='learning_rate', range=[0.005, 0.01]),
sherpa.Continuous(name='beta1', range=[0.45, 0.55]),
sherpa.Continuous(name='beta2', range=[0.95, 1.0])
]
return params
def test_get_best_result_larger():
parameters = [sherpa.Choice('a', [0, 1]),
sherpa.Choice('b', [3, 4])]
results_df = pandas.DataFrame(collections.OrderedDict(
[('Trial-ID', list(range(1, 9))),
('Status', [sherpa.TrialStatus.COMPLETED] * 8),
('stage', [1] * 8),
('a', [0, 0, 0, 0, 1, 1, 1, 1]),
('b', [3, 3, 4, 4, 3, 3, 4, 4]),
('Objective', [1., 1.1, 2.1, 2.2, 5., 5.1, 6., 6.1])]
))
rs = sherpa.algorithms.RandomSearch()
gs = SequentialTesting(algorithm=rs,
K=4,
n=(3, 6, 9),
P=0.5)
best_config = gs.get_best_result(parameters, results_df,
lower_is_better=False)
assert best_config == {'a': 1, 'b': 4, 'MeanObjective': 6.05}
def test_get_best_result():
parameters = [sherpa.Choice('a', [1,2,3])]
gs = sherpa.algorithms.GridSearch()
study = sherpa.Study(parameters=parameters, algorithm=gs,
lower_is_better=True,
disable_dashboard=True)
objectives = [1.1,1.2,1.3]
for obj, trial in zip(objectives, study):
study.add_observation(trial, objective=obj)
study.finalize(trial)
assert study.get_best_result()['a'] == 1
def test_repeat_rs():
parameters = [sherpa.Continuous('a', [0, 1]),
sherpa.Choice('b', ['x', 'y', 'z'])]
rs = sherpa.algorithms.RandomSearch(max_num_trials=10)
rs = sherpa.algorithms.Repeat(algorithm=rs, num_times=10)
config_repeat = {}
for i in range(10):
config = rs.get_suggestion(parameters=parameters)
assert config != config_repeat
for j in range(9):
config_repeat = rs.get_suggestion(parameters=parameters)
assert config == config_repeat
assert rs.get_suggestion(parameters=parameters) == sherpa.AlgorithmState.DONE
def test_chain():
parameters = [sherpa.Continuous('a', [0, 1]),
sherpa.Choice('b', ['x', 'y', 'z'])]
algorithm = sherpa.algorithms.Chain(algorithms=[sherpa.algorithms.GridSearch(num_grid_points=2),
sherpa.algorithms.RandomSearch(max_num_trials=10)])
study = sherpa.Study(parameters=parameters, algorithm=algorithm,
lower_is_better=True,
disable_dashboard=True)
for trial in study:
if trial.id < 7:
assert trial.parameters['a'] in [0, 1]
assert trial.parameters['b'] == ['x', 'y', 'z'][trial.id%3-1]
else:
assert trial.parameters['a'] not in [0, 1]
def test_repeat_get_best_result_called_midway():
parameters = [sherpa.Choice('a', [1,2,3])]
gs = sherpa.algorithms.GridSearch()
gs = sherpa.algorithms.Repeat(algorithm=gs, num_times=3)
study = sherpa.Study(parameters=parameters, algorithm=gs,
lower_is_better=True,
disable_dashboard=True)
objectives = [2.1,2.2,2.3, 9., 0.1, 9.1, 1.1,1.2,1.3]
expected = [None, None, 1, 1, 1, 1, 1, 1, 3]
for exp, obj, trial in zip(expected, objectives, study):
study.add_observation(trial, objective=obj)
study.finalize(trial)
assert study.get_best_result().get('a') == exp
def test_transformers():
parameter = sherpa.Choice('choice', ['a', 'b', 'c', 'd'])
transformer = BayesianOptimization.ChoiceTransformer(parameter)
assert np.all(
transformer.transform(['d', 'c', 'b', 'a']) == np.flip(np.eye(4),
axis=0))
assert all(
transformer.reverse(transformer.transform(['d', 'c', 'b', 'a'])) ==
np.array(['d', 'c', 'b', 'a']))
parameter = sherpa.Continuous('continuous', [0., 0.4])
transformer = BayesianOptimization.ContinuousTransformer(parameter)
assert np.all(
transformer.transform([0.2, 0.4, 0.]) == np.array([0.5, 1.0, 0.0]))
assert np.all(
transformer.reverse(transformer.transform([0.2, 0.4, 0.])) == np.array(
[0.2, 0.4, 0.]))
parameter = sherpa.Continuous('continuous-log', [0.00001, 0.1], 'log')
transformer = BayesianOptimization.ContinuousTransformer(parameter)
print(transformer.transform([0.01]))
assert np.all(
transformer.transform([0.0001, 0.001, 0.01]) == np.array(
[0.25, 0.5, 0.75]))
print(transformer.reverse(transformer.transform([0.0001, 0.001, 0.01])))
assert np.all(
transformer.reverse(transformer.transform([0.0001, 0.001, 0.01])) ==
np.array([0.0001, 0.001, 0.01]))
parameter = sherpa.Discrete('discrete', [0, 12])
transformer = BayesianOptimization.DiscreteTransformer(parameter)
assert np.all(
transformer.transform([3, 6, 9]) == np.array([0.25, 0.5, 0.75]))
assert np.all(
transformer.reverse(transformer.transform([3, 6, 9])) == np.array(
[3, 6, 9]))
assert np.all(transformer.reverse([0.2, 0.3, 0.4]) == np.array([2, 4, 5]))
parameter = sherpa.Discrete('discrete-log', [10, 100000], 'log')
transformer = BayesianOptimization.DiscreteTransformer(parameter)
assert np.all(
transformer.transform([10, 100, 1000, 10000, 100000]) == np.array(
[0., 0.25, 0.5, 0.75, 1.]))
assert np.all(
transformer.reverse(
transformer.transform([10, 100, 1000, 10000, 100000])) == np.array(
[10, 100, 1000, 10000, 100000]))
def test_grid_search():
parameters = [sherpa.Choice('choice', ['a', 'b']),
sherpa.Continuous('continuous', [2, 3])]
alg = sherpa.algorithms.GridSearch(num_grid_points=2)
suggestion = alg.get_suggestion(parameters)
seen = set()
while suggestion != sherpa.AlgorithmState.DONE:
seen.add((suggestion['choice'], suggestion['continuous']))
suggestion = alg.get_suggestion(parameters)
assert seen == {('a', 2.0),
('a', 3.0),
('b', 2.0),
('b', 3.0)}
def hyper_param(self, epochs):
parameters = [
sherpa.Continuous('learning_rate', [1e-4, 1e-2]),
sherpa.Discrete('num_units', [32, 128]),
sherpa.Choice('activation', ['relu', 'adam', 'sigmoid'])
]
algorithm = bayesian_optimization.GPyOpt(max_num_trials=50)
study = sherpa.Study(parameters=parameters,
algorithm=algorithm,
lower_is_better=False)
x_test = self._label / 300
y_test = self._label
# Create model
model = models.Sequential()
model.add(
layers.Embedding(self.totalwords,
64,
input_length=maxSequenceLen - 1))
model.add(layers.LSTM(128))
model.add(layers.Dense(self.totalwords, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
epochs = epochs
for trial in study:
lr = trial.parameters['learning_rate']
num_units = trial.parameters['num_units']
act = trial.parameters['activation']
for i in range(epochs):
model.fit(self.predictors, self._label, batch_size=self.batch)
loss, accuracy = model.evaluate(x_test, y_test)
study.add_observation(trial=trial,
iteration=i,
objective=accuracy,
context={'loss': loss})
if study.should_trial_stop(trial):
break
study.finalize(trial=trial)
print(study.get_best_result())
def test_repeat_wait_for_completion():
parameters = [
sherpa.Continuous('a', [0, 1]),
sherpa.Choice('b', ['x', 'y', 'z'])
]
rs = sherpa.algorithms.RandomSearch(max_num_trials=10)
rs = sherpa.algorithms.Repeat(algorithm=rs,
num_times=10,
wait_for_completion=True)
study = sherpa.Study(parameters=parameters,
algorithm=rs,
lower_is_better=True,
disable_dashboard=True)
for i in range(10):
tnew = study.get_suggestion()
print(tnew.parameters)
assert isinstance(tnew.parameters, dict)
config = tnew.parameters
study.add_observation(tnew, objective=float(i), iteration=1)
study.finalize(tnew)
for j in range(9):
t = study.get_suggestion()
config_repeat = t.parameters
assert config == config_repeat
if j < 8:
study.add_observation(t, objective=float(i), iteration=1)
study.finalize(t)
# Obtained 10/10 repeats for the configuration, but haven't added
# results for the last one. Obtaining a new suggestion we expect WAIT.
twait = study.get_suggestion()
assert twait == sherpa.AlgorithmState.WAIT
study.add_observation(t, objective=float(i), iteration=1)
study.finalize(t)
tdone = study.get_suggestion()
assert tdone is None
def test_random_search():
parameters = [sherpa.Continuous('a', [0, 1]),
sherpa.Choice('b', ['x', 'y', 'z'])]
rs = sherpa.algorithms.RandomSearch(max_num_trials=10)
last_config = {}
for i in range(10):
config = rs.get_suggestion(parameters=parameters)
assert config != last_config
last_config = config
assert rs.get_suggestion(parameters=parameters) == sherpa.AlgorithmState.DONE
rs = sherpa.algorithms.RandomSearch()
last_config = {}
for _ in range(1000):
config = rs.get_suggestion(parameters=parameters)
assert config != last_config
last_config = config
def test_3d():
def obj_func(x, y, z):
assert isinstance(x, float)
assert isinstance(y, str)
assert isinstance(z, int)
# Global maximum of 4 is at x=4
return -4. * numpy.exp(-(x - 4.)**2 / 10.) * numpy.cos(
1.5 * (x - 4.))**2 - int(y) * z
parameters = [
sherpa.Continuous('x', [0., 7.]),
sherpa.Choice('y', ["-1", "0", "1"]),
sherpa.Discrete('z', [1, 5])
]
bayesian_optimization = GPyOpt(max_concurrent=1,
max_num_trials=100,
model_type='GP',
acquisition_type='EI')
study = sherpa.Study(algorithm=bayesian_optimization,
parameters=parameters,
lower_is_better=True,
disable_dashboard=True)
for trial in study:
print("Trial {}:\t{}".format(trial.id, trial.parameters))
fval = obj_func(**trial.parameters)
print("Function Value: {}".format(fval))
study.add_observation(trial=trial, iteration=1, objective=fval)
study.finalize(trial, status='COMPLETED')
rval = study.get_best_result()
print(rval)
assert numpy.isclose(rval['x'], 4., atol=0.1)
assert rval['y'] == 1
assert rval['z'] == 5
