def suggest_sample(self, number_of_samples=1):
"""
Returns a suggested next point to evaluate.
"""
utility_parameter_sample = self.utility.sample_parameter(number_of_samples=1)
model_sample = self.model.get_copy_of_model_sample()
X_evaluated = np.copy(model_sample[0].X)
Y_evaluated = []
for j in range(len(model_sample)):
Y_evaluated.append(np.copy(model_sample[j].Y))
self.X_aux = np.copy(X_evaluated)
self.Y_aux = deepcopy(Y_evaluated)
def objective_func_sample(x):
x_new = np.atleast_2d(x)
y_new = []
self.X_aux = np.vstack((self.X_aux, x_new))
for j in range(len(model_sample)):
y_new.append(model_sample[j].posterior_samples_f(x_new, size=1, full_cov=True)[0])
self.Y_aux[j] = np.vstack((self.Y_aux[j], y_new[j]))
model_sample[j].set_XY(self.X_aux, self.Y_aux[j])
y_new = np.squeeze(np.asarray(y_new))
val = np.atleast_1d(self.utility.eval_func(y_new, utility_parameter_sample))
return -val
d0 = initial_design('random', self.space, 1)
suggested_sample = apply_optimizer(self.optimizer, d0, f=objective_func_sample,
context_manager=self.context_manager, space=self.space, maxfevals=600)[0]
suggested_sample = np.atleast_2d(suggested_sample)
return suggested_sample
def _parallel_optimization_wrapper(self, x0):
return apply_optimizer(self.optimizer,
x0,
self.f,
None,
self.f_df,
context_manager=self.context_manager,
space=self.space)
def optimize(self, f=None, df=None, f_df=None, duplicate_manager=None):
"""
Optimizes the input function.
:param f: function to optimize.
:param df: gradient of the function to optimize.
:param f_df: returns both the function to optimize and its gradient.
"""
self.f = f
self.df = df
self.f_df = f_df
# Update the optimizer, in case context has beee passed.
self.optimizer = choose_optimizer(
self.optimizer_name, self.context_manager.noncontext_bounds)
# Selecting the anchor points and removing duplicates
if self.type_anchor_points_logic == max_objective_anchor_points_logic:
anchor_points_generator = ObjectiveAnchorPointsGenerator(
self.space, random_design_type, f, self.n_starting)
elif self.type_anchor_points_logic == thompson_sampling_anchor_points_logic:
anchor_points_generator = ThompsonSamplingAnchorPointsGenerator(
self.space, sobol_design_type, self.model)
# Select the anchor points (with context)
anchor_points, anchor_points_values = anchor_points_generator.get(
num_anchor=self.n_anchor,
duplicate_manager=duplicate_manager,
context_manager=self.context_manager,
get_scores=True)
# Baseline points
if self.include_baseline_points:
X_baseline = []
if self.full_parameter_support:
utility_parameter_samples = self.utility.parameter_distribution.support
else:
utility_parameter_samples = self.utility.parameter_distribution.sample(
self.number_of_utility_parameter_samples)
for i in range(len(utility_parameter_samples)):
marginal_argmax = self._current_marginal_argmax(
utility_parameter_samples[i])
X_baseline.append(marginal_argmax[0, :])
X_baseline = np.atleast_2d(X_baseline)
fX_baseline = f(X_baseline)[:, 0]
anchor_points = np.vstack((anchor_points, X_baseline))
anchor_points_values = np.concatenate(
(anchor_points_values, fX_baseline))
print('Anchor points:')
print(anchor_points)
print('Anchor points values:')
print(anchor_points_values)
if self.parallel:
pool = Pool(4)
optimized_points = pool.map(self._parallel_optimization_wrapper,
anchor_points)
print('optimized points (parallel):')
else:
optimized_points = [
apply_optimizer(self.optimizer,
a,
f=f,
df=None,
f_df=f_df,
duplicate_manager=duplicate_manager,
context_manager=self.context_manager,
space=self.space) for a in anchor_points
]
print('Optimized points (sequential):')
print(optimized_points)
x_min, fx_min = min(optimized_points, key=lambda t: t[1])
fx_min = np.squeeze(fx_min)
if self.include_baseline_points:
fx_min_baseline = fX_baseline.min()
if fx_min_baseline < fx_min:
print('Baseline point was best found.')
optimal_indices = np.atleast_1d(np.argmin(fX_baseline))
index = random.choice(optimal_indices)
x_min = np.atleast_2d(X_baseline[index, :])
fx_min = fX_baseline[index]
elif fx_min_baseline == fx_min:
print('Baseline point is a good as best optimized point.')
use_baseline_point = np.random.binomial(1, 0.5, 1)
if use_baseline_point:
print('Baseline point will be used.')
optimal_indices = np.atleast_1d(np.argmin(fX_baseline))
index = random.choice(optimal_indices)
x_min = np.atleast_2d(X_baseline[index, :])
fx_min = fX_baseline[index]
print('Acquisition value of selected point: {}'.format(fx_min))
return x_min, fx_min