def test_evaluate_log_likelihood_at_points(self):
"""Check that ``evaluate_log_likelihood_at_hyperparameter_list`` computes and orders results correctly."""
num_sampled = 5
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(
self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
num_to_eval = 10
domain_bounds = [
self.gp_test_environment_input.hyperparameter_interval
] * self.gp_test_environment_input.num_hyperparameters
domain = TensorProductDomain(domain_bounds)
hyperparameters_to_evaluate = domain.generate_uniform_random_points_in_domain(
num_to_eval)
test_values = evaluate_log_likelihood_at_hyperparameter_list(
lml, hyperparameters_to_evaluate)
for i, value in enumerate(test_values):
lml.hyperparameters = hyperparameters_to_evaluate[i, ...]
truth = lml.compute_log_likelihood()
assert value == truth
def test_grad_log_likelihood_pings(self):
"""Ping test (compare analytic result to finite difference) the log likelihood gradient wrt hyperparameters."""
numpy.random.seed(2014)
h = 2.0e-4
tolerance = 5.0e-6
for num_sampled in self.num_sampled_list:
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
analytic_grad = lml.compute_grad_log_likelihood()
for k in xrange(lml.num_hyperparameters):
hyperparameters_old = lml.hyperparameters
# hyperparamter + h
hyperparameters_p = numpy.copy(hyperparameters_old)
hyperparameters_p[k] += h
lml.hyperparameters = hyperparameters_p
cov_p = lml.compute_log_likelihood()
lml.hyperparameters = hyperparameters_old
# hyperparamter - h
hyperparameters_m = numpy.copy(hyperparameters_old)
hyperparameters_m[k] -= h
lml.hyperparameters = hyperparameters_m
cov_m = lml.compute_log_likelihood()
lml.hyperparameters = hyperparameters_old
# calculate finite diff
fd_grad = (cov_p - cov_m) / (2.0 * h)
self.assert_scalar_within_relative(fd_grad, analytic_grad[k], tolerance)
def test_grad_log_likelihood_pings(self):
"""Ping test (compare analytic result to finite difference) the log likelihood gradient wrt hyperparameters."""
numpy.random.seed(2014)
h = 2.0e-4
tolerance = 5.0e-6
for num_sampled in self.num_sampled_list:
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
analytic_grad = lml.compute_grad_log_likelihood()
for k in xrange(lml.num_hyperparameters):
hyperparameters_old = lml.hyperparameters
# hyperparamter + h
hyperparameters_p = numpy.copy(hyperparameters_old)
hyperparameters_p[k] += h
lml.hyperparameters = hyperparameters_p
cov_p = lml.compute_log_likelihood()
lml.hyperparameters = hyperparameters_old
# hyperparamter - h
hyperparameters_m = numpy.copy(hyperparameters_old)
hyperparameters_m[k] -= h
lml.hyperparameters = hyperparameters_m
cov_m = lml.compute_log_likelihood()
lml.hyperparameters = hyperparameters_old
# calculate finite diff
fd_grad = (cov_p - cov_m) / (2.0 * h)
self.assert_scalar_within_relative(fd_grad, analytic_grad[k], tolerance)
def test_multistart_hyperparameter_optimization(self):
"""Check that multistart optimization (gradient descent) can find the optimum hyperparameters."""
random_state = numpy.random.get_state()
numpy.random.seed(87612)
max_num_steps = 200 # this is generally *too few* steps; we configure it this way so the test will run quickly
max_num_restarts = 5
num_steps_averaged = 0
gamma = 0.2
pre_mult = 1.0
max_relative_change = 0.3
tolerance = 1.0e-11
gd_parameters = GradientDescentParameters(
max_num_steps,
max_num_restarts,
num_steps_averaged,
gamma,
pre_mult,
max_relative_change,
tolerance,
)
num_multistarts = 3 # again, too few multistarts; but we want the test to run reasonably quickly
num_sampled = 10
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(
self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
domain = TensorProductDomain(
[ClosedInterval(1.0, 4.0)] *
self.gp_test_environment_input.num_hyperparameters)
hyperparameter_optimizer = GradientDescentOptimizer(
domain, lml, gd_parameters)
best_hyperparameters = multistart_hyperparameter_optimization(
hyperparameter_optimizer, num_multistarts)
# Check that gradients are small
lml.hyperparameters = best_hyperparameters
gradient = lml.compute_grad_log_likelihood()
self.assert_vector_within_relative(
gradient, numpy.zeros(self.num_hyperparameters), tolerance)
# Check that output is in the domain
assert domain.check_point_inside(best_hyperparameters) is True
numpy.random.set_state(random_state)
def test_multistart_hyperparameter_optimization(self):
"""Check that multistart optimization (gradient descent) can find the optimum hyperparameters."""
random_state = numpy.random.get_state()
numpy.random.seed(87612)
max_num_steps = 200 # this is generally *too few* steps; we configure it this way so the test will run quickly
max_num_restarts = 5
num_steps_averaged = 0
gamma = 0.2
pre_mult = 1.0
max_relative_change = 0.3
tolerance = 1.0e-11
gd_parameters = GradientDescentParameters(
max_num_steps,
max_num_restarts,
num_steps_averaged,
gamma,
pre_mult,
max_relative_change,
tolerance,
)
num_multistarts = 3 # again, too few multistarts; but we want the test to run reasonably quickly
num_sampled = 10
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
domain = TensorProductDomain([ClosedInterval(1.0, 4.0)] * self.gp_test_environment_input.num_hyperparameters)
hyperparameter_optimizer = GradientDescentOptimizer(domain, lml, gd_parameters)
best_hyperparameters = multistart_hyperparameter_optimization(hyperparameter_optimizer, num_multistarts)
# Check that gradients are small
lml.hyperparameters = best_hyperparameters
gradient = lml.compute_grad_log_likelihood()
self.assert_vector_within_relative(gradient, numpy.zeros(self.num_hyperparameters), tolerance)
# Check that output is in the domain
assert domain.check_point_inside(best_hyperparameters) is True
numpy.random.set_state(random_state)
def test_evaluate_log_likelihood_at_points(self):
"""Check that ``evaluate_log_likelihood_at_hyperparameter_list`` computes and orders results correctly."""
num_sampled = 5
self.gp_test_environment_input.num_sampled = num_sampled
_, gaussian_process = self._build_gaussian_process_test_data(self.gp_test_environment_input)
python_cov, historical_data = gaussian_process.get_core_data_copy()
lml = GaussianProcessLogMarginalLikelihood(python_cov, historical_data)
num_to_eval = 10
domain_bounds = [self.gp_test_environment_input.hyperparameter_interval] * self.gp_test_environment_input.num_hyperparameters
domain = TensorProductDomain(domain_bounds)
hyperparameters_to_evaluate = domain.generate_uniform_random_points_in_domain(num_to_eval)
test_values = evaluate_log_likelihood_at_hyperparameter_list(lml, hyperparameters_to_evaluate)
for i, value in enumerate(test_values):
lml.hyperparameters = hyperparameters_to_evaluate[i, ...]
truth = lml.compute_log_likelihood()
assert value == truth
kt_mean = -1. * np.ones(int(num_is *
(num_is + 1) / 2)) # the entries are in log space
i = 0
advance = 1
while i < len(kt_mean):
kt_mean[i] = 0.0 # diagonal entries are set to e^(0.0) = 1
advance += 1
i += advance
kt_var = 100. * np.ones(len(kt_mean))
# construct prior for hypers of regular exp kernel
prior_mean_IS_0 = np.concatenate(
([prior_alpha_mean], [1.] * obj_func_min.getDim()))
prior_var_IS_0 = np.concatenate(
([np.power(prior_alpha_mean / 2., 2.)], [25.] * obj_func_min.getDim()))
prior_mean = np.concatenate((kt_mean, prior_mean_IS_0))
prior_var = np.concatenate((kt_var, prior_var_IS_0))
### setup cov and gp model
cov = ProductKernel(prior_mean, obj_func_min.getDim() + 1, num_is)
gp_likelihood = GaussianProcessLogMarginalLikelihood(cov, transformed_data)
slice_sampler = SliceSampler(prior_mean, prior_var, 1, prior_mean)
hypers_mat = np.array([None] * (n_samples * len(prior_mean))).reshape(
(n_samples, len(prior_mean)))
for i in range(n_burnin):
h = slice_sampler.sample(gp_likelihood)
print "burnin {0}, {1}".format(i, h)
for i in range(n_samples):
hypers_mat[i, :] = slice_sampler.sample(gp_likelihood)
print "sample {0}, {1}".format(i, hypers_mat[i, :])
sql_util_miso.write_array_to_table(table_name, hypers_mat[i, :])
""" Matthias' code ends
"""
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt
from moe.optimal_learning.python.python_version.log_likelihood import GaussianProcessLogMarginalLikelihood
print "prior mean\n{0}\nprior sig diag\n{1}".format(prior_mean,
numpy.diag(prior_sig))
print "num_is {0}".format(obj_func_max.getNumIS() - 1 + separateIS0)
hyperparam_search_domain = pythonTensorProductDomain(
[ClosedInterval(bound[0], bound[1]) for bound in hyper_bounds])
print "hyper bounds\n{0}".format(hyper_bounds)
cov = MixedSquareExponential(hyperparameters=prior_mean,
total_dim=obj_func_max.getDim() + 1,
num_is=obj_func_max.getNumIS() - 1 + separateIS0)
gp_likelihood = GaussianProcessLogMarginalLikelihood(cov, historical_data)
with PdfPages('posterior_plot_1.pdf') as pdf:
for d in range(len(prior_mean)):
x_list = numpy.linspace(hyper_bounds[d][0], hyper_bounds[d][1], 100)
y_list = numpy.zeros(len(x_list))
x = numpy.copy(prior_mean)
for i, e in enumerate(x_list):
print "plot {0}, {1}th pt".format(d, i)
x[d] = e
gp_likelihood.set_hyperparameters(x)
y_list[i] = gp_likelihood.compute_log_likelihood(
) + prior.compute_log_likelihood(x)
plt.figure()
plt.plot(x_list, y_list, 'r-o')
plt.title(str(d))
