def test_generate_specs(self):
multiple_spec = MultipleSpecEntity({
'problem_names':
self.problem_names,
'dim_xs':
self.dim_xs,
'choose_noises':
self.choose_noises,
'bounds_domain_xs': [[self.bound]],
'number_points_each_dimensions':
self.number_points_each_dimensions,
'method_optimizations':
self.method_optimizations,
'training_names': [self.training_name],
'bounds_domains':
self.bounds_domain_xs,
'type_boundss': [[0]],
'n_trainings': [10],
'type_kernels': [self.type_kernel],
'dimensionss': [self.dimensions],
})
specs = SpecService.generate_specs(1, multiple_spec)
assert len(specs) == 1
for s in specs:
s.validate()
def test_generate_dict_spec(self):
spec = SpecService.generate_dict_spec(self.problem_name, self.dim_x,
self.bounds_domain_x,
self.training_name,
self.type_kernel,
self.dimensions)
assert spec == {
'problem_name': self.problem_name,
'dim_x': self.dim_x,
'bounds_domain_x': self.bounds_domain_x,
'training_name': self.training_name,
'bounds_domain': self.bounds_domain_x,
'number_points_each_dimension': [10],
'choose_noise': True,
'method_optimization': 'sbo',
'type_bounds': [0],
'n_training': 10,
'points': [],
'noise': False,
'n_samples': 0,
'random_seed': 1,
'parallel': True,
'type_kernel': [SCALED_KERNEL, MATERN52_NAME],
'dimensions': [1],
'name_model': 'gp_fitting_gaussian',
'mle': True,
'thinning': 0,
'n_burning': 0,
'max_steps_out': 1,
'training_data': {},
'x_domain': [],
'distribution': UNIFORM_FINITE,
'parameters_distribution': {},
'minimize': False,
'n_iterations': 5,
'debug': False,
'kernel_values': [],
'mean_value': [],
'var_noise_value': [],
'same_correlation': False,
'number_points_each_dimension_debug': None,
'monte_carlo_sbo': False,
'n_restarts_mc': 1,
'n_samples_mc': 1,
'factr_mc': 1000000000000.0,
'maxiter_mc': 1000,
'n_restarts': 10,
'use_only_training_points': True,
'n_best_restarts': 10,
'n_samples_parameters': 0,
'n_best_restarts_mc': 1,
'n_best_restarts_mean': 100,
'n_restarts_mean': 1000,
'maxepoch': 10,
'maxepoch_mean': 20,
'method_opt_mc': 'dogleg',
'n_samples_parameters_mean': 15,
}
else:
sign = False
if same_rs == 0:
same_rs = False
else:
same_rs = True
if rs_up == -1:
rs_up = None
if n_iterations == -1:
n_iterations = None
multiple_spec_file = args.specfile
multiple_spec = MultipleSpecEntity.from_json(multiple_spec_file)
if not only_plot:
SpecService.collect_multi_spec_results(multiple_spec,
total_iterations=n_iterations,
rs_lw=rs_lw,
rs_up=rs_up,
same_random_seeds=same_rs,
sign=sign,
combine_method=combine_method)
plot_aggregate_results(multiple_spec,
y_label=args.y_label,
n_iterations=n_iterations,
repeat_ei=repeat_ei)
specs = SpecService.generate_dict_multiple_spec(
n_specs=n_specs,
problem_names=problem_name,
dim_xs=dim_x,
bounds_domain_xs=bounds_domain_x,
training_names=training_name,
type_kernels=type_kernel,
dimensionss=dimensions,
bounds_domains=bounds_domain,
number_points_each_dimensions=number_points_each_dimension,
n_trainings=n_training,
random_seeds=random_seed,
type_boundss=type_bounds,
x_domains=x_domain,
mles=mle,
distributions=distribution,
parallels=parallel,
thinnings=thinning,
n_burnings=n_burning,
max_steps_outs=max_steps_out,
n_iterationss=n_iterations,
same_correlations=same_correlation,
debugs=debug,
number_points_each_dimension_debugs=number_points_each_dimension_debug,
monte_carlo_sbos=monte_carlo_sbo,
n_samples_mcs=n_samples_mc,
n_restarts_mcs=n_restarts_mc,
factr_mcs=factr_mc,
maxiter_mcs=maxiter_mc,
n_restartss=n_restarts,
n_best_restartss=n_best_restarts,
use_only_training_pointss=use_only_training_points,
method_optimizations=method_optimization,
n_samples_parameterss=n_samples_parameters,
n_restarts_means=n_restarts_mean,
n_best_restarts_means=n_best_restarts_mean,
n_best_restarts_mcs=n_best_restarts_mc,
maxepochs=maxepoch,
method_opt_mcs=method_opt_mc,
n_samples_parameters_means=n_samples_parameters_mean,
maxepoch_means=maxepoch_mean,
threshold_sbos=threshold_sbo,
parallel_trainings=parallel_training,
noises=noises,
n_sampless=n_sampless,
parameters_distributions=parameters_distributions,
optimize_only_posterior_means=optimize_only_posterior_means,
start_optimize_posterior_means=start_optimize_posterior_means,
simplex_domain=simplex_domain)
method_optimization = SBO_METHOD
n_samples_parameters = 5
n_restarts_mean = 100
n_best_restarts_mean = 10
method_opt_mc = DOGLEG
maxepoch = 10
n_samples_parameters_mean = 20
maxepoch_mean = 20
threshold_sbo = 0.001
spec = SpecService.generate_dict_spec(
problem_name, dim_x, bounds_domain_x, training_name, type_kernel, dimensions,
bounds_domain=bounds_domain, n_training=n_training, random_seed=random_seed,
type_bounds=type_bounds, x_domain=x_domain, mle=mle,
number_points_each_dimension=number_points_each_dimension, distribution=distribution,
parallel=parallel, thinning=thinning, n_burning=n_burning, max_steps_out=max_steps_out,
n_iterations=n_iterations, same_correlation=same_correlation, debug=debug,
number_points_each_dimension_debug=number_points_each_dimension_debug,
monte_carlo_sbo=monte_carlo_sbo, n_samples_mc=n_samples_mc, n_restarts_mc=n_restarts_mc,
factr_mc=factr_mc, maxiter_mc=maxiter_mc, n_restarts=n_restarts,
n_best_restarts=n_best_restarts, use_only_training_points=use_only_training_points,
method_optimization=method_optimization, n_samples_parameters=n_samples_parameters,
n_restarts_mean=n_restarts_mean, n_best_restarts_mean=n_best_restarts_mean,
n_best_restarts_mc=n_best_restarts_mc, maxepoch=maxepoch, method_opt_mc=method_opt_mc,
n_samples_parameters_mean=n_samples_parameters_mean, maxepoch_mean=maxepoch_mean,
threshold_sbo=threshold_sbo)
print ujson.dumps(spec, indent=4)
default=5)
parser.add_argument('--output_file',
type=str,
help='output file',
default='output.json')
args = parser.parse_args()
output_file = args.output_file
n_spec = int(args.spec)
output_file = 'spec_%d' % n_spec + '_' + output_file
multiple_spec = MultipleSpecEntity.from_json(args.multiple_spec)
spec = SpecService.generate_specs(n_spec, multiple_spec)
result = BGO.run_spec(spec)
with open(args.output_file, 'w') as f:
ujson.dump(result, f)
# results = []
# for spec in specs:
# result = {
# 'problem_name': spec.problem_name,
# 'method_optimization': spec.method_optimization,
# 'result': BGO.run_spec(spec)
# }
# results.append(result)
def test_generate_dic_specs(self):
specs = SpecService.generate_dict_multiple_spec(
1, self.problem_names, self.dim_xs, self.bounds_domain_xs,
[self.training_name], [self.type_kernel], [self.dimensions])
assert specs == {
'problem_names': self.problem_names,
'dim_xs': self.dim_xs,
'bounds_domain_xs': self.bounds_domain_xs,
'training_names': [self.training_name],
'bounds_domains': self.bounds_domain_xs,
'number_points_each_dimensions': [[10]],
'choose_noises': [True],
'method_optimizations': ['sbo'],
'type_boundss': [[0]],
'n_trainings': [10],
'pointss': [[]],
'noises': [False],
'n_sampless': [0],
'random_seeds': [1],
'parallels': [True],
'type_kernels': [[SCALED_KERNEL, MATERN52_NAME]],
'dimensionss': [[1]],
'name_models': ['gp_fitting_gaussian'],
'mles': [True],
'thinnings': [0],
'n_burnings': [0],
'max_steps_outs': [1],
'training_datas': [{}],
'distributions': [UNIFORM_FINITE],
'minimizes': [False],
'n_iterationss': [5],
'parameters_distributions': [{}],
'x_domains': [[]],
'kernel_valuess': [[]],
'mean_values': [[]],
'var_noise_values': [[]],
}
specs_ = SpecService.generate_dict_multiple_spec(
2, ['toy', 'toy_2'], [1, 2], [[[2, 3]], [[5, 8]]],
[self.training_name, 'test_spec_2'], [self.type_kernel],
[self.dimensions])
assert specs_ == {
'problem_names': ['toy', 'toy_2'],
'dim_xs': [1, 2],
'bounds_domain_xs': [[[2, 3]], [[5, 8]]],
'training_names': [self.training_name, 'test_spec_2'],
'bounds_domains': [[[2, 3]], [[5, 8]]],
'number_points_each_dimensions': [[10], [10, 10]],
'choose_noises': [True, True],
'method_optimizations': ['sbo', 'sbo'],
'type_boundss': [[0], [0]],
'n_trainings': [10, 10],
'pointss': [[], []],
'noises': [False, False],
'n_sampless': [0, 0],
'random_seeds': [1, 1],
'parallels': [True, True],
'type_kernels': [[SCALED_KERNEL, MATERN52_NAME],
[SCALED_KERNEL, MATERN52_NAME]],
'dimensionss': [[1], [1]],
'name_models': ['gp_fitting_gaussian', 'gp_fitting_gaussian'],
'mles': [True, True],
'thinnings': [0, 0],
'n_burnings': [0, 0],
'max_steps_outs': [1, 1],
'training_datas': [{}, {}],
'distributions': [UNIFORM_FINITE, UNIFORM_FINITE],
'minimizes': [False, False],
'n_iterationss': [5, 5],
'parameters_distributions': [{}, {}],
'x_domains': [[], []],
'kernel_valuess': [[], []],
'mean_values': [[], []],
'var_noise_values': [[], []],
}