def test_compute_posteriors():
np.random.seed(42)
arr_range_1 = np.array([
[0.0, 10.0],
[-2.0, 2.0],
[-5.0, 5.0],
])
dim_X = arr_range_1.shape[0]
num_X = 5
X = np.random.randn(num_X, dim_X)
Y = np.random.randn(num_X, 1)
model_bo = BO(arr_range_1, str_acq='ei', str_exp=None)
hyps = utils_covariance.get_hyps(model_bo.str_cov,
dim=dim_X,
use_ard=model_bo.use_ard,
use_gp=False)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X, hyps, model_bo.str_cov)
X_test = model_bo.get_samples('sobol', num_samples=10, seed=111)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(1, Y, X_test, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, 1, X_test, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, 1, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, 1, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, 1, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1.0)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 'abc')
pred_mean, pred_std = model_bo.compute_posteriors(X, Y, X_test, cov_X_X,
inv_cov_X_X, hyps)
assert len(pred_mean.shape) == 1
assert len(pred_std.shape) == 1
assert pred_mean.shape[0] == pred_mean.shape[0] == X_test.shape[0]
def predict_with_hyps(X_train: np.ndarray, Y_train: np.ndarray, X_test: np.ndarray, hyps: dict,
str_cov: str=constants.STR_COV,
prior_mu: constants.TYPING_UNION_CALLABLE_NONE=None,
debug: bool=False
) -> constants.TYPING_TUPLE_THREE_ARRAYS:
"""
This function returns posterior mean and posterior standard deviation
functions over `X_test`, computed by Gaussian process regression with
`X_train`, `Y_train`, and `hyps`.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param X_test: inputs. Shape: (l, d) or (l, m, d).
:type X_test: numpy.ndarray
:param hyps: dictionary of hyperparameters for Gaussian process.
:type hyps: dict.
:param str_cov: the name of covariance function.
:type str_cov: str., optional
:param prior_mu: None, or prior mean function.
:type prior_mu: NoneType, or callable, optional
:param debug: flag for printing log messages.
:type debug: bool., optional
:returns: a tuple of posterior mean function over `X_test`, posterior
standard deviation function over `X_test`, and posterior covariance
matrix over `X_test`. Shape: ((l, 1), (l, 1), (l, l)).
:rtype: tuple of (numpy.ndarray, numpy.ndarray, numpy.ndarray)
:raises: AssertionError
"""
utils_gp.validate_common_args(X_train, Y_train, str_cov, prior_mu, debug, X_test)
assert isinstance(hyps, dict)
utils_covariance.check_str_cov('predict_with_hyps', str_cov,
X_train.shape, shape_X2=X_test.shape)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(X_train,
hyps, str_cov, debug=debug)
mu_Xs, sigma_Xs, Sigma_Xs = predict_with_cov(X_train, Y_train, X_test,
cov_X_X, inv_cov_X_X, hyps, str_cov=str_cov,
prior_mu=prior_mu, debug=debug)
return mu_Xs, sigma_Xs, Sigma_Xs
def test_compute_acquisitions_set():
np.random.seed(42)
arr_range_1 = np.array([
[0.0, 10.0],
[-2.0, 2.0],
[-5.0, 5.0],
])
dim_X = arr_range_1.shape[0]
num_X = 5
num_instances = 4
X = np.random.randn(num_X, num_instances, dim_X)
Y = np.random.randn(num_X, 1)
model_bo = BO(arr_range_1, str_acq='pi', str_cov='set_se', str_exp='test')
hyps = utils_covariance.get_hyps(model_bo.str_cov,
dim=dim_X,
use_ard=model_bo.use_ard,
use_gp=False)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X, hyps, model_bo.str_cov)
X_test = np.array([
[
[1.0, 0.0, 0.0, 1.0],
[2.0, -1.0, 2.0, 1.0],
[3.0, -2.0, 4.0, 1.0],
],
[
[4.0, 2.0, -3.0, 1.0],
[5.0, 0.0, -2.0, 1.0],
[6.0, -2.0, -1.0, 1.0],
],
])
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, hyps)
def optimize(
self,
X_train: np.ndarray,
Y_train: np.ndarray,
str_sampling_method: str = constants.STR_SAMPLING_METHOD_AO,
num_samples: int = constants.NUM_SAMPLES_AO,
str_mlm_method: str = constants.STR_MLM_METHOD,
) -> constants.TYPING_TUPLE_ARRAY_DICT:
"""
It computes acquired example, candidates of acquired examples,
acquisition function values for the candidates, covariance matrix,
inverse matrix of the covariance matrix, hyperparameters optimized,
and execution times.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param str_sampling_method: the name of sampling method for
acquisition function optimization.
:type str_sampling_method: str., optional
:param num_samples: the number of samples.
:type num_samples: int., optional
:param str_mlm_method: the name of marginal likelihood maximization
method for Gaussian process regression.
:type str_mlm_method: str., optional
:returns: acquired example and dictionary of information. Shape: ((d, ), dict.).
:rtype: (numpy.ndarray, dict.)
:raises: AssertionError
"""
assert isinstance(X_train, np.ndarray)
assert isinstance(Y_train, np.ndarray)
assert isinstance(str_sampling_method, str)
assert isinstance(num_samples, int)
assert isinstance(str_mlm_method, str)
assert len(X_train.shape) == 2
assert len(Y_train.shape) == 2
assert Y_train.shape[1] == 1
assert X_train.shape[0] == Y_train.shape[0]
assert X_train.shape[1] == self.num_dim
assert num_samples > 0
assert str_sampling_method in constants.ALLOWED_SAMPLING_METHOD
assert str_mlm_method in constants.ALLOWED_MLM_METHOD
time_start = time.time()
Y_train_orig = Y_train
if self.normalize_Y and str_mlm_method != 'converged':
if self.debug:
self.logger.debug('Responses are normalized.')
Y_train = utils_bo.normalize_min_max(Y_train)
time_start_surrogate = time.time()
if str_mlm_method == 'regular':
cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel(
X_train,
Y_train,
self.prior_mu,
self.str_cov,
str_optimizer_method=self.str_optimizer_method_gp,
str_modelselection_method=self.str_modelselection_method,
use_ard=self.use_ard,
debug=self.debug)
elif str_mlm_method == 'combined':
from bayeso.gp import gp_likelihood
from bayeso.utils import utils_gp
from bayeso.utils import utils_covariance
prior_mu_train = utils_gp.get_prior_mu(self.prior_mu, X_train)
neg_log_ml_best = np.inf
cov_X_X_best = None
inv_cov_X_X_best = None
hyps_best = None
for cur_str_optimizer_method in ['BFGS', 'Nelder-Mead']:
cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel(
X_train,
Y_train,
self.prior_mu,
self.str_cov,
str_optimizer_method=cur_str_optimizer_method,
str_modelselection_method=self.str_modelselection_method,
use_ard=self.use_ard,
debug=self.debug)
cur_neg_log_ml_ = gp_likelihood.neg_log_ml(
X_train,
Y_train,
utils_covariance.convert_hyps(
self.str_cov, hyps, fix_noise=constants.FIX_GP_NOISE),
self.str_cov,
prior_mu_train,
use_ard=self.use_ard,
fix_noise=constants.FIX_GP_NOISE,
use_gradient=False,
debug=self.debug)
if cur_neg_log_ml_ < neg_log_ml_best:
neg_log_ml_best = cur_neg_log_ml_
cov_X_X_best = cov_X_X
inv_cov_X_X_best = inv_cov_X_X
hyps_best = hyps
cov_X_X = cov_X_X_best
inv_cov_X_X = inv_cov_X_X_best
hyps = hyps_best
elif str_mlm_method == 'converged':
fix_noise = constants.FIX_GP_NOISE
if self.is_optimize_hyps:
cov_X_X, inv_cov_X_X, hyps = gp_kernel.get_optimized_kernel(
X_train,
Y_train,
self.prior_mu,
self.str_cov,
str_optimizer_method=self.str_optimizer_method_gp,
str_modelselection_method=self.str_modelselection_method,
use_ard=self.use_ard,
debug=self.debug)
self.is_optimize_hyps = not utils_bo.check_hyps_convergence(
self.historical_hyps, hyps, self.str_cov, fix_noise)
else: # pragma: no cover
if self.debug:
self.logger.debug('hyps converged.')
hyps = self.historical_hyps[-1]
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X_train,
hyps,
self.str_cov,
fix_noise=fix_noise,
debug=self.debug)
else: # pragma: no cover
raise ValueError('optimize: missing condition for str_mlm_method.')
self.historical_hyps.append(hyps)
time_end_surrogate = time.time()
time_start_acq = time.time()
fun_negative_acquisition = lambda X_test: -1.0 * self.compute_acquisitions(
X_test, X_train, Y_train, cov_X_X, inv_cov_X_X, hyps)
next_point, next_points = self._optimize(
fun_negative_acquisition,
str_sampling_method=str_sampling_method,
num_samples=num_samples)
time_end_acq = time.time()
acquisitions = fun_negative_acquisition(next_points)
time_end = time.time()
dict_info = {
'next_points': next_points,
'acquisitions': acquisitions,
'Y_original': Y_train_orig,
'Y_normalized': Y_train,
'cov_X_X': cov_X_X,
'inv_cov_X_X': inv_cov_X_X,
'hyps': hyps,
'time_surrogate': time_end_surrogate - time_start_surrogate,
'time_acq': time_end_acq - time_start_acq,
'time_overall': time_end - time_start,
}
if self.debug:
self.logger.debug('overall time consumed to acquire: %.4f sec.',
time_end - time_start)
return next_point, dict_info
def get_optimized_kernel(
X_train: np.ndarray,
Y_train: np.ndarray,
prior_mu: constants.TYPING_UNION_CALLABLE_NONE,
str_cov: str,
str_optimizer_method: str = constants.STR_OPTIMIZER_METHOD_GP,
str_modelselection_method: str = constants.STR_MODELSELECTION_METHOD,
use_ard: bool = constants.USE_ARD,
fix_noise: bool = constants.FIX_GP_NOISE,
debug: bool = False) -> constants.TYPING_TUPLE_TWO_ARRAYS_DICT:
"""
This function computes the kernel matrix optimized by optimization
method specified, its inverse matrix, and the optimized hyperparameters.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param prior_mu: prior mean function or None.
:type prior_mu: callable or NoneType
:param str_cov: the name of covariance function.
:type str_cov: str.
:param str_optimizer_method: the name of optimization method.
:type str_optimizer_method: str., optional
:param str_modelselection_method: the name of model selection method.
:type str_modelselection_method: str., optional
:param use_ard: flag for using automatic relevance determination.
:type use_ard: bool., optional
:param fix_noise: flag for fixing a noise.
:type fix_noise: bool., optional
:param debug: flag for printing log messages.
:type debug: bool., optional
:returns: a tuple of kernel matrix over `X_train`, kernel matrix
inverse, and dictionary of hyperparameters.
:rtype: tuple of (numpy.ndarray, numpy.ndarray, dict.)
:raises: AssertionError, ValueError
"""
# TODO: check to input same fix_noise to convert_hyps and restore_hyps
utils_gp.validate_common_args(X_train, Y_train, str_cov, prior_mu, debug)
assert isinstance(str_optimizer_method, str)
assert isinstance(str_modelselection_method, str)
assert isinstance(use_ard, bool)
assert isinstance(fix_noise, bool)
utils_covariance.check_str_cov('get_optimized_kernel', str_cov,
X_train.shape)
assert str_optimizer_method in constants.ALLOWED_OPTIMIZER_METHOD_GP
assert str_modelselection_method in constants.ALLOWED_MODELSELECTION_METHOD
use_gradient = bool(str_optimizer_method != 'Nelder-Mead')
# TODO: Now, use_gradient is fixed as False.
# use_gradient = False
time_start = time.time()
if debug:
logger.debug('str_optimizer_method: %s', str_optimizer_method)
logger.debug('str_modelselection_method: %s',
str_modelselection_method)
logger.debug('use_gradient: %s', use_gradient)
prior_mu_train = utils_gp.get_prior_mu(prior_mu, X_train)
if str_cov in constants.ALLOWED_COV_BASE:
num_dim = X_train.shape[1]
elif str_cov in constants.ALLOWED_COV_SET:
num_dim = X_train.shape[2]
use_gradient = False
if str_modelselection_method == 'ml':
neg_log_ml_ = lambda hyps: gp_likelihood.neg_log_ml(
X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
use_ard=use_ard,
fix_noise=fix_noise,
use_gradient=use_gradient,
debug=debug)
elif str_modelselection_method == 'loocv':
# TODO: add use_ard.
neg_log_ml_ = lambda hyps: gp_likelihood.neg_log_pseudo_l_loocv(
X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
fix_noise=fix_noise,
debug=debug)
use_gradient = False
else: # pragma: no cover
raise ValueError(
'get_optimized_kernel: missing conditions for str_modelselection_method.'
)
hyps_converted = utils_covariance.convert_hyps(str_cov,
utils_covariance.get_hyps(
str_cov,
num_dim,
use_ard=use_ard),
fix_noise=fix_noise)
if str_optimizer_method in ['BFGS', 'SLSQP']:
result_optimized = scipy.optimize.minimize(neg_log_ml_,
hyps_converted,
method=str_optimizer_method,
jac=use_gradient,
options={'disp': False})
if debug:
logger.debug('negative log marginal likelihood: %.6f',
result_optimized.fun)
logger.debug('scipy message: %s', result_optimized.message)
result_optimized = result_optimized.x
elif str_optimizer_method in ['L-BFGS-B', 'SLSQP-Bounded']:
if str_optimizer_method == 'SLSQP-Bounded':
str_optimizer_method = 'SLSQP'
bounds = utils_covariance.get_range_hyps(str_cov,
num_dim,
use_ard=use_ard,
fix_noise=fix_noise)
result_optimized = scipy.optimize.minimize(neg_log_ml_,
hyps_converted,
method=str_optimizer_method,
bounds=bounds,
jac=use_gradient,
options={'disp': False})
if debug:
logger.debug('negative log marginal likelihood: %.6f',
result_optimized.fun)
logger.debug('scipy message: %s', result_optimized.message)
result_optimized = result_optimized.x
elif str_optimizer_method in ['Nelder-Mead']:
result_optimized = scipy.optimize.minimize(neg_log_ml_,
hyps_converted,
method=str_optimizer_method,
options={'disp': False})
if debug:
logger.debug('negative log marginal likelihood: %.6f',
result_optimized.fun)
logger.debug('scipy message: %s', result_optimized.message)
result_optimized = result_optimized.x
else: # pragma: no cover
raise ValueError(
'get_optimized_kernel: missing conditions for str_optimizer_method'
)
hyps = utils_covariance.restore_hyps(str_cov,
result_optimized,
use_ard=use_ard,
fix_noise=fix_noise)
hyps = utils_covariance.validate_hyps_dict(hyps, str_cov, num_dim)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X_train, hyps, str_cov, fix_noise=fix_noise, debug=debug)
time_end = time.time()
if debug:
logger.debug('hyps optimized: %s', utils_logger.get_str_hyps(hyps))
logger.debug('time consumed to construct gpr: %.4f sec.',
time_end - time_start)
return cov_X_X, inv_cov_X_X, hyps
def test_get_kernel_inverse():
dim_X = 3
X = np.reshape(np.arange(0, 9), (3, dim_X))
hyps = utils_covariance.get_hyps('se', dim_X)
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(1, hyps, 'se')
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(np.arange(0, 100), hyps, 'se')
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(X, 1, 'se')
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(X, hyps, 1)
with pytest.raises(ValueError) as error:
package_target.get_kernel_inverse(X, hyps, 'abc')
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(X, hyps, 'se', debug=1)
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(X, hyps, 'se', use_gradient='abc')
with pytest.raises(AssertionError) as error:
package_target.get_kernel_inverse(X, hyps, 'se', fix_noise='abc')
cov_X_X, inv_cov_X_X, grad_cov_X_X = package_target.get_kernel_inverse(
X, hyps, 'se')
print(cov_X_X)
print(inv_cov_X_X)
truth_cov_X_X = np.array([[1.00011000e+00, 1.37095909e-06, 3.53262857e-24],
[1.37095909e-06, 1.00011000e+00, 1.37095909e-06],
[3.53262857e-24, 1.37095909e-06,
1.00011000e+00]])
truth_inv_cov_X_X = np.array(
[[9.99890012e-01, -1.37065753e-06, 1.87890871e-12],
[-1.37065753e-06, 9.99890012e-01, -1.37065753e-06],
[1.87890871e-12, -1.37065753e-06, 9.99890012e-01]])
assert (np.abs(cov_X_X - truth_cov_X_X) < TEST_EPSILON).all()
assert (np.abs(inv_cov_X_X - truth_inv_cov_X_X) < TEST_EPSILON).all()
assert cov_X_X.shape == inv_cov_X_X.shape
cov_X_X, inv_cov_X_X, grad_cov_X_X = package_target.get_kernel_inverse(
X, hyps, 'se', use_gradient=True, fix_noise=True)
print(grad_cov_X_X)
print(grad_cov_X_X.shape)
truth_grad_cov_X_X = np.array(
[[[2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[
2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05,
1.233863177745676e-05
],
[
7.06525714e-24, 1.2717462859922906e-22, 1.2717462859922906e-22,
1.2717462859922906e-22
]],
[[
2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05,
1.233863177745676e-05
], [2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[
2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05,
1.233863177745676e-05
]],
[[
7.06525714e-24, 1.2717462859922906e-22, 1.2717462859922906e-22,
1.2717462859922906e-22
],
[
2.74191817e-06, 1.233863177745676e-05, 1.233863177745676e-05,
1.233863177745676e-05
], [2.00002000e+00, 0.00000000e+00, 0.00000000e+00,
0.00000000e+00]]])
assert (np.abs(cov_X_X - truth_cov_X_X) < TEST_EPSILON).all()
assert (np.abs(inv_cov_X_X - truth_inv_cov_X_X) < TEST_EPSILON).all()
assert (np.abs(grad_cov_X_X - truth_grad_cov_X_X) < TEST_EPSILON).all()
assert cov_X_X.shape == inv_cov_X_X.shape == grad_cov_X_X.shape[:2]
def test_compute_acquisitions():
np.random.seed(42)
arr_range_1 = np.array([
[0.0, 10.0],
[-2.0, 2.0],
[-5.0, 5.0],
])
dim_X = arr_range_1.shape[0]
num_X = 5
X = np.random.randn(num_X, dim_X)
Y = np.random.randn(num_X, 1)
model_bo = BO(arr_range_1, str_acq='pi', str_exp='test')
hyps = utils_covariance.get_hyps(model_bo.str_cov,
dim=dim_X,
use_ard=model_bo.use_ard)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X, hyps, model_bo.str_cov)
X_test = model_bo.get_samples('sobol', num_samples=10, seed=111)
truth_X_test = np.array([
[
3.328958908095956,
-1.8729291455820203,
0.2839687094092369,
],
[
8.11741182114929,
0.3799784183502197,
-0.05574141861870885,
],
[
6.735238193068653,
-0.9264274807646871,
3.631770429201424,
],
[
2.13300823001191,
1.3245289996266365,
-3.547573888208717,
],
[
0.6936023756861687,
-0.018464308232069016,
-2.1043178741820157,
],
[
5.438151848502457,
1.7285785367712379,
2.0298107899725437,
],
[
9.085266247857362,
-1.2144776917994022,
-4.31197423255071,
],
[
4.468362366314977,
0.5345162367448211,
4.0739051485434175,
],
[
3.9395463559776545,
-0.5726078534498811,
-4.846788686700165,
],
[
9.92871844675392,
1.1744442842900753,
4.774723623413593,
],
])
for elem_1 in X_test:
for elem_2 in elem_1:
print(elem_2)
assert np.all(np.abs(X_test - truth_X_test) < TEST_EPSILON)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(1, X, Y, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, 1, Y, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, 1, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, Y, 1, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, 1, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X, 1)
with pytest.raises(AssertionError) as error:
model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X,
'abc')
acqs = model_bo.compute_acquisitions(X_test, X, Y, cov_X_X, inv_cov_X_X,
hyps)
print('acqs')
for elem_1 in acqs:
print(elem_1)
truth_acqs = np.array([
0.9140836833364618,
0.7893422923284443,
0.7893819649518585,
0.780516205172671,
1.170379060386938,
0.7889956503605072,
0.7893345684226016,
0.789773864915061,
0.7908883762985802,
0.7893339801719917,
])
assert isinstance(acqs, np.ndarray)
assert len(acqs.shape) == 1
assert X_test.shape[0] == acqs.shape[0]
assert np.all(np.abs(acqs - truth_acqs) < TEST_EPSILON)
def test_compute_posteriors_set():
np.random.seed(42)
arr_range_1 = np.array([
[0.0, 10.0],
[-2.0, 2.0],
[-5.0, 5.0],
])
dim_X = arr_range_1.shape[0]
num_X = 5
num_instances = 4
X = np.random.randn(num_X, num_instances, dim_X)
Y = np.random.randn(num_X, 1)
model_bo = BO(arr_range_1, str_acq='pi', str_cov='set_se', str_exp=None)
hyps = utils_covariance.get_hyps(model_bo.str_cov,
dim=dim_X,
use_ard=model_bo.use_ard)
cov_X_X, inv_cov_X_X, _ = covariance.get_kernel_inverse(
X, hyps, model_bo.str_cov)
X_test = np.array([
[
[1.0, 0.0, 0.0, 1.0],
[2.0, -1.0, 2.0, 1.0],
[3.0, -2.0, 4.0, 1.0],
],
[
[4.0, 2.0, -3.0, 1.0],
[5.0, 0.0, -2.0, 1.0],
[6.0, -2.0, -1.0, 1.0],
],
])
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(1, Y, X_test, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, 1, X_test, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, 1, cov_X_X, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, 1, inv_cov_X_X, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, 1, hyps)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 1.0)
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, 'abc')
with pytest.raises(AssertionError) as error:
model_bo.compute_posteriors(X, Y, X_test, cov_X_X, inv_cov_X_X, hyps)
pred_mean, pred_std = model_bo.compute_posteriors(X, Y,
X_test[:, :, :dim_X],
cov_X_X, inv_cov_X_X,
hyps)
assert len(pred_mean.shape) == 1
assert len(pred_std.shape) == 1
assert pred_mean.shape[0] == pred_mean.shape[0] == X_test.shape[0]
def neg_log_ml(X_train: np.ndarray,
Y_train: np.ndarray,
hyps: np.ndarray,
str_cov: str,
prior_mu_train: np.ndarray,
use_ard: bool = constants.USE_ARD,
fix_noise: bool = constants.FIX_GP_NOISE,
use_gradient: bool = True,
debug: bool = False) -> constants.TYPING_UNION_FLOAT_FA:
"""
This function computes a negative log marginal likelihood.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param hyps: hyperparameters for Gaussian process. Shape: (h, ).
:type hyps: numpy.ndarray
:param str_cov: the name of covariance function.
:type str_cov: str.
:param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1).
:type prior_mu_train: numpy.ndarray
:param use_ard: flag for automatic relevance determination.
:type use_ard: bool., optional
:param fix_noise: flag for fixing a noise.
:type fix_noise: bool., optional
:param use_gradient: flag for computing and returning gradients of
negative log marginal likelihood.
:type use_gradient: bool., optional
:param debug: flag for printing log messages.
:type debug: bool., optional
:returns: negative log marginal likelihood, or (negative log marginal
likelihood, gradients of the likelihood).
:rtype: float, or tuple of (float, np.ndarray)
:raises: AssertionError
"""
utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug)
assert isinstance(hyps, np.ndarray)
assert isinstance(prior_mu_train, np.ndarray)
assert isinstance(use_ard, bool)
assert isinstance(fix_noise, bool)
assert isinstance(use_gradient, bool)
assert len(prior_mu_train.shape) == 2
assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0]
utils_covariance.check_str_cov('neg_log_ml', str_cov, X_train.shape)
num_X = float(X_train.shape[0])
hyps = utils_covariance.restore_hyps(str_cov,
hyps,
use_ard=use_ard,
fix_noise=fix_noise,
use_gp=False)
new_Y_train = Y_train - prior_mu_train
nu = hyps['dof']
cov_X_X, inv_cov_X_X, grad_cov_X_X = covariance.get_kernel_inverse(
X_train,
hyps,
str_cov,
fix_noise=fix_noise,
use_gradient=use_gradient,
debug=debug)
alpha = np.dot(inv_cov_X_X, new_Y_train)
beta = np.squeeze(np.dot(np.dot(new_Y_train.T, inv_cov_X_X), new_Y_train))
first_term = -0.5 * num_X * np.log((nu - 2.0) * np.pi)
sign_second_term, second_term = np.linalg.slogdet(cov_X_X)
# TODO: it should be checked.
if sign_second_term <= 0: # pragma: no cover
second_term = 0.0
second_term = -0.5 * second_term
third_term = np.log(
scipy.special.gamma(
(nu + num_X) / 2.0) / scipy.special.gamma(nu / 2.0))
fourth_term = -0.5 * (nu + num_X) * np.log(1.0 + beta / (nu - 2.0))
log_ml_ = np.squeeze(first_term + second_term + third_term + fourth_term)
log_ml_ /= num_X
if use_gradient:
assert grad_cov_X_X is not None
grad_log_ml_ = np.zeros(grad_cov_X_X.shape[2] + 1)
first_term_grad = ((nu + num_X) /
(nu + beta - 2.0) * np.dot(alpha, alpha.T) -
inv_cov_X_X)
nu_grad = -num_X / (2.0 * (nu - 2.0))\
+ scipy.special.digamma((nu + num_X) / 2.0)\
- scipy.special.digamma(nu / 2.0)\
- 0.5 * np.log(1.0 + beta / (nu - 2.0))\
+ (nu + num_X) * beta / (2.0 * (nu - 2.0)**2 + 2.0 * beta * (nu - 2.0))
if fix_noise:
grad_log_ml_[0] = nu_grad
else:
grad_log_ml_[1] = nu_grad
for ind in range(0, grad_cov_X_X.shape[2]):
cur_grad = 0.5 * np.trace(
np.dot(first_term_grad, grad_cov_X_X[:, :, ind]))
if fix_noise:
grad_log_ml_[ind + 1] = cur_grad
else:
if ind == 0:
cur_ind = 0
else:
cur_ind = ind + 1
grad_log_ml_[cur_ind] = cur_grad
if use_gradient:
return -1.0 * log_ml_, -1.0 * grad_log_ml_ / num_X
return -1.0 * log_ml_
def neg_log_ml(X_train: np.ndarray, Y_train: np.ndarray, hyps: np.ndarray,
str_cov: str, prior_mu_train: np.ndarray,
use_ard: bool=constants.USE_ARD,
fix_noise: bool=constants.FIX_GP_NOISE,
use_cholesky: bool=True,
use_gradient: bool=True,
debug: bool=False
) -> constants.TYPING_UNION_FLOAT_FA:
"""
This function computes a negative log marginal likelihood.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param hyps: hyperparameters for Gaussian process. Shape: (h, ).
:type hyps: numpy.ndarray
:param str_cov: the name of covariance function.
:type str_cov: str.
:param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1).
:type prior_mu_train: numpy.ndarray
:param use_ard: flag for automatic relevance determination.
:type use_ard: bool., optional
:param fix_noise: flag for fixing a noise.
:type fix_noise: bool., optional
:param use_cholesky: flag for using a cholesky decomposition.
:type use_cholesky: bool., optional
:param use_gradient: flag for computing and returning gradients of
negative log marginal likelihood.
:type use_gradient: bool., optional
:param debug: flag for printing log messages.
:type debug: bool., optional
:returns: negative log marginal likelihood, or (negative log marginal
likelihood, gradients of the likelihood).
:rtype: float, or tuple of (float, np.ndarray)
:raises: AssertionError
"""
# TODO: add use_ard.
utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug)
assert isinstance(hyps, np.ndarray)
assert isinstance(prior_mu_train, np.ndarray)
assert isinstance(use_ard, bool)
assert isinstance(fix_noise, bool)
assert isinstance(use_cholesky, bool)
assert isinstance(use_gradient, bool)
assert len(prior_mu_train.shape) == 2
assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0]
utils_covariance.check_str_cov('neg_log_ml', str_cov, X_train.shape)
hyps = utils_covariance.restore_hyps(str_cov, hyps, use_ard=use_ard, fix_noise=fix_noise)
new_Y_train = Y_train - prior_mu_train
if use_cholesky:
cov_X_X, lower, grad_cov_X_X = covariance.get_kernel_cholesky(X_train,
hyps, str_cov, fix_noise=fix_noise, use_gradient=use_gradient,
debug=debug)
alpha = scipy.linalg.cho_solve((lower, True), new_Y_train)
first_term = -0.5 * np.dot(new_Y_train.T, alpha)
second_term = -1.0 * np.sum(np.log(np.diagonal(lower) + constants.JITTER_LOG))
if use_gradient:
assert grad_cov_X_X is not None
first_term_grad = np.einsum("ik,jk->ijk", alpha, alpha)
first_term_grad -= np.expand_dims(scipy.linalg.cho_solve((lower, True),
np.eye(cov_X_X.shape[0])), axis=2)
grad_log_ml_ = 0.5 * np.einsum("ijl,ijk->kl", first_term_grad, grad_cov_X_X)
grad_log_ml_ = np.sum(grad_log_ml_, axis=1)
else:
# TODO: use_gradient is fixed.
use_gradient = False
cov_X_X, inv_cov_X_X, grad_cov_X_X = covariance.get_kernel_inverse(X_train,
hyps, str_cov, fix_noise=fix_noise, use_gradient=use_gradient,
debug=debug)
first_term = -0.5 * np.dot(np.dot(new_Y_train.T, inv_cov_X_X), new_Y_train)
sign_second_term, second_term = np.linalg.slogdet(cov_X_X)
# TODO: It should be checked.
if sign_second_term <= 0: # pragma: no cover
second_term = 0.0
second_term = -0.5 * second_term
third_term = -float(X_train.shape[0]) / 2.0 * np.log(2.0 * np.pi)
log_ml_ = np.squeeze(first_term + second_term + third_term)
log_ml_ /= X_train.shape[0]
if use_gradient:
return -1.0 * log_ml_, -1.0 * grad_log_ml_ / X_train.shape[0]
return -1.0 * log_ml_
def neg_log_pseudo_l_loocv(X_train: np.ndarray, Y_train: np.ndarray, hyps: np.ndarray,
str_cov: str, prior_mu_train: np.ndarray,
fix_noise: bool=constants.FIX_GP_NOISE,
debug: bool=False
) -> float:
"""
It computes a negative log pseudo-likelihood using leave-one-out cross-validation.
:param X_train: inputs. Shape: (n, d) or (n, m, d).
:type X_train: numpy.ndarray
:param Y_train: outputs. Shape: (n, 1).
:type Y_train: numpy.ndarray
:param hyps: hyperparameters for Gaussian process. Shape: (h, ).
:type hyps: numpy.ndarray
:param str_cov: the name of covariance function.
:type str_cov: str.
:param prior_mu_train: the prior values computed by get_prior_mu(). Shape: (n, 1).
:type prior_mu_train: numpy.ndarray
:param fix_noise: flag for fixing a noise.
:type fix_noise: bool., optional
:param debug: flag for printing log messages.
:type debug: bool., optional
:returns: negative log pseudo-likelihood.
:rtype: float
:raises: AssertionError
"""
# TODO: add use_ard.
utils_gp.validate_common_args(X_train, Y_train, str_cov, None, debug)
assert isinstance(hyps, np.ndarray)
assert isinstance(prior_mu_train, np.ndarray)
assert isinstance(fix_noise, bool)
assert len(prior_mu_train.shape) == 2
assert X_train.shape[0] == Y_train.shape[0] == prior_mu_train.shape[0]
utils_covariance.check_str_cov('neg_log_pseudo_l_loocv', str_cov, X_train.shape)
num_data = X_train.shape[0]
hyps = utils_covariance.restore_hyps(str_cov, hyps, fix_noise=fix_noise)
_, inv_cov_X_X, _ = covariance.get_kernel_inverse(X_train, hyps,
str_cov, fix_noise=fix_noise, debug=debug)
log_pseudo_l_ = 0.0
for ind_data in range(0, num_data):
# TODO: check this.
# cur_X_train = np.vstack((X_train[:ind_data], X_train[ind_data+1:]))
# cur_Y_train = np.vstack((Y_train[:ind_data], Y_train[ind_data+1:]))
# cur_X_test = np.expand_dims(X_train[ind_data], axis=0)
cur_Y_test = Y_train[ind_data]
cur_mu = np.squeeze(cur_Y_test) \
- np.dot(inv_cov_X_X, Y_train)[ind_data] / inv_cov_X_X[ind_data, ind_data]
cur_sigma = np.sqrt(1.0 / (inv_cov_X_X[ind_data, ind_data] + constants.JITTER_COV))
first_term = -0.5 * np.log(cur_sigma**2)
second_term = -0.5 * (np.squeeze(cur_Y_test - cur_mu))**2 / (cur_sigma**2)
third_term = -0.5 * np.log(2.0 * np.pi)
cur_log_pseudo_l_ = first_term + second_term + third_term
log_pseudo_l_ += cur_log_pseudo_l_
log_pseudo_l_ /= num_data
log_pseudo_l_ *= -1.0
return log_pseudo_l_
