def test_cov_matern32():
with pytest.raises(AssertionError) as error:
covariance.cov_matern32(np.zeros((1, 2)), np.zeros((1, 2)), np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern32(np.zeros((1, 2)), np.zeros((1, 3)), np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern32(np.zeros((1, 3)), np.zeros((1, 2)), np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern32(np.zeros((1, 2)), np.zeros((1, 2)), np.array([1.0, 1.0]), 1)
assert np.abs(covariance.cov_matern32(np.zeros((1, 2)), np.zeros((1, 2)), 1.0, 0.1)[0] - 0.01) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xs = np.array([[2.0, 1.0, 1.0]])
cur_hyps = utils_covariance.get_hyps('matern32', 3)
cov_ = covariance.cov_matern32(X, Xs, cur_hyps['lengthscales'], cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.19914827347145583
assert np.abs(cov_[0] - truth_cov_) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xs = np.array([[2.0, 1.0, 1.0], [0.0, 0.0, 0.0]])
cur_hyps = utils_covariance.get_hyps('matern32', 3)
cur_hyps['lengthscales'] = 1.0
cov_ = covariance.cov_matern32(X, Xs, cur_hyps['lengthscales'], cur_hyps['signal'])
print(cov_)
truth_cov_ = np.array([[0.19914827, 0.1013397]])
assert np.all(np.abs(cov_[0] - truth_cov_) < TEST_EPSILON)
def test_cov_matern52():
with pytest.raises(AssertionError) as error:
package_target.cov_matern52(np.zeros((1, 2)), np.zeros((1, 2)),
np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_matern52(np.zeros((1, 2)), np.zeros((1, 3)),
np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_matern52(np.zeros((1, 3)), np.zeros((1, 2)),
np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_matern52(np.zeros((1, 2)), np.zeros((1, 2)),
np.array([1.0, 1.0]), 1)
assert np.abs(
package_target.cov_matern52(np.zeros((1, 2)), np.zeros(
(1, 2)), 1.0, 0.1)[0] - 0.01) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xp = np.array([[2.0, 1.0, 1.0]])
cur_hyps = utils_covariance.get_hyps('matern52', 3)
cov_ = package_target.cov_matern52(X, Xp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.20532087608359792
assert np.abs(cov_[0] - truth_cov_) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xp = np.array([[2.0, 1.0, 1.0], [0.0, 0.0, 0.0]])
cur_hyps = utils_covariance.get_hyps('matern52', 3)
cur_hyps['lengthscales'] = 1.0
cov_ = package_target.cov_matern52(X, Xp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = np.array([[0.20532088, 0.09657724]])
assert np.all(np.abs(cov_[0] - truth_cov_) < TEST_EPSILON)
def test_cov_se():
with pytest.raises(AssertionError) as error:
package_target.cov_se(np.zeros((1, 2)), np.zeros((1, 2)),
np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_se(np.zeros((1, 2)), np.zeros((1, 3)),
np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_se(np.zeros((1, 3)), np.zeros((1, 2)),
np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
package_target.cov_se(np.zeros((1, 2)), np.zeros((1, 2)),
np.array([1.0, 1.0]), 1)
assert np.abs(
package_target.cov_se(np.zeros((1, 2)), np.zeros(
(1, 2)), 1.0, 0.1)[0] - 0.01) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xp = np.array([[2.0, 1.0, 1.0]])
cur_hyps = utils_covariance.get_hyps('se', 3)
cov_ = package_target.cov_se(X, Xp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.22313016014842987
assert np.abs(cov_[0] - truth_cov_) < TEST_EPSILON
X = np.array([[1.0, 2.0, 0.0]])
Xp = np.array([[2.0, 1.0, 1.0], [0.0, 0.0, 0.0]])
cur_hyps = utils_covariance.get_hyps('se', 3)
cur_hyps['lengthscales'] = 1.0
cov_ = package_target.cov_se(X, Xp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = np.array([[0.22313016, 0.082085]])
assert np.all(np.abs(cov_[0] - truth_cov_) < TEST_EPSILON)
def test_cov_set():
num_instances = 5
num_dim = 3
str_cov = 'matern52'
with pytest.raises(AssertionError) as error:
covariance.cov_set(1, np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim)), np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_set('abc', np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim)), np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_set(str_cov, np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim)), np.array([1.0, 1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_set(str_cov, np.zeros((num_instances, num_dim+1)), np.zeros((num_instances, num_dim)), np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_set(str_cov, np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim+1)), np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_set(str_cov, np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim)), np.array([1.0, 1.0, 1.0]), 1)
assert np.abs(covariance.cov_set(str_cov, np.zeros((num_instances, num_dim)), np.zeros((num_instances, num_dim)), 1.0, 0.1) - 0.01) < TEST_EPSILON
bx = np.array([[1.0, 2.0, 0.0], [2.0, 1.0, 0.0]])
bxp = np.array([[2.0, 1.0, 1.0], [2.0, 2.0, 2.0]])
cur_hyps = utils_covariance.get_hyps('matern52', 3)
cov_ = covariance.cov_set(str_cov, bx, bxp, cur_hyps['lengthscales'], cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.23061736638896702
assert np.abs(cov_ - truth_cov_) < TEST_EPSILON
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:
gp.get_kernel_inverse(1, hyps, 'se')
with pytest.raises(AssertionError) as error:
gp.get_kernel_inverse(np.arange(0, 100), hyps, 'se')
with pytest.raises(AssertionError) as error:
gp.get_kernel_inverse(X, 1, 'se')
with pytest.raises(AssertionError) as error:
gp.get_kernel_inverse(X, hyps, 1)
with pytest.raises(ValueError) as error:
gp.get_kernel_inverse(X, hyps, 'abc')
with pytest.raises(AssertionError) as error:
gp.get_kernel_inverse(X, hyps, 'se', debug=1)
cov_X_X, inv_cov_X_X = gp.get_kernel_inverse(X, hyps, 'se')
print(cov_X_X)
print(inv_cov_X_X)
truth_cov_X_X = [
[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 = [
[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
def test_get_kernel_cholesky():
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:
gp_common.get_kernel_cholesky(1, hyps, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_cholesky(np.arange(0, 10), hyps, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_cholesky(X, 1, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_cholesky(X, hyps, 1)
with pytest.raises(ValueError) as error:
gp_common.get_kernel_cholesky(X, hyps, 'abc')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_cholesky(X, hyps, 'se', debug=1)
cov_X_X, lower, _ = gp_common.get_kernel_cholesky(X, hyps, 'se')
print(cov_X_X)
print(lower)
truth_cov_X_X = [
[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_lower = [
[1.00005500e+00, 0.00000000e+00, 0.00000000e+00],
[1.37088369e-06, 1.00005500e+00, 0.00000000e+00],
[3.53243429e-24, 1.37088369e-06, 1.00005500e+00],
]
assert (np.abs(cov_X_X - truth_cov_X_X) < TEST_EPSILON).all()
assert (np.abs(lower - truth_lower) < TEST_EPSILON).all()
assert cov_X_X.shape == lower.shape
def test_cov_matern52():
with pytest.raises(AssertionError) as error:
covariance.cov_matern52(np.zeros(2), np.zeros(2),
np.array([1.0, 1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern52(np.zeros(2), np.zeros(3), np.array([1.0, 1.0]),
0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern52(np.zeros(3), np.zeros(2), np.array([1.0, 1.0]),
0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_matern52(np.zeros(2), np.zeros(2), np.array([1.0, 1.0]),
1)
assert np.abs(
covariance.cov_matern52(np.zeros(2), np.zeros(2), 1.0, 0.1) -
0.01) < TEST_EPSILON
bx = np.array([1.0, 2.0, 0.0])
bxp = np.array([2.0, 1.0, 1.0])
cur_hyps = utils_covariance.get_hyps('matern52', 3)
cov_ = covariance.cov_matern52(bx, bxp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.20532087608359792
assert np.abs(cov_ - truth_cov_) < TEST_EPSILON
def test_neg_log_pseudo_l_loocv():
dim_X = 3
str_cov = 'se'
X = np.reshape(np.arange(0, 9), (3, dim_X))
Y = np.expand_dims(np.arange(3, 10, 3), axis=1)
dict_hyps = utils_covariance.get_hyps(str_cov, dim_X)
arr_hyps = utils_covariance.convert_hyps(str_cov,
dict_hyps,
fix_noise=constants.FIX_GP_NOISE)
prior_mu_X = np.zeros((3, 1))
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(np.arange(0, 3), Y, arr_hyps,
str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X, np.arange(0, 3), arr_hyps,
str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X, Y, dict_hyps, str_cov,
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X, Y, arr_hyps, 1, prior_mu_X)
with pytest.raises(ValueError) as error:
package_target.neg_log_pseudo_l_loocv(X, Y, arr_hyps, 'abc',
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X, Y, arr_hyps, str_cov,
np.arange(0, 3))
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(
np.reshape(np.arange(0, 12), (4, dim_X)), Y, arr_hyps, str_cov,
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(
X, np.expand_dims(np.arange(0, 4), axis=1), arr_hyps, str_cov,
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(
X, Y, arr_hyps, str_cov, np.expand_dims(np.arange(0, 4), axis=1))
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
fix_noise=1)
with pytest.raises(AssertionError) as error:
package_target.neg_log_pseudo_l_loocv(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
debug=1)
neg_log_pseudo_l_ = package_target.neg_log_pseudo_l_loocv(
X, Y, arr_hyps, str_cov, prior_mu_X)
print(neg_log_pseudo_l_)
truth_log_pseudo_l_ = 21.916822991658695
assert np.abs(neg_log_pseudo_l_ - truth_log_pseudo_l_) < TEST_EPSILON
def test_grad_cov_main():
cur_hyps = utils_covariance.get_hyps('se', 2)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main(123, np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', 123, np.zeros((10, 2)), cur_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), 123, cur_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), np.zeros((10, 2)), 123, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, 'abc')
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('abc', np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, True, same_X_Xs='abc')
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, True, same_X_Xs=False)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_main('se', np.zeros((10, 2)), np.zeros((10, 2)), cur_hyps, True, jitter='abc')
grad_cov_ = covariance.grad_cov_main('se', np.ones((1, 2)), np.ones((1, 2)), cur_hyps, True)
print(grad_cov_)
truth_grad_cov_ = np.array([[[2.00002, 0.0, 0.0]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = covariance.grad_cov_main('se', np.ones((1, 2)), np.ones((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 2.00002, 0.0, 0.0]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
cur_hyps['lengthscales'] = 1.0
grad_cov_ = covariance.grad_cov_main('se', np.ones((1, 2)), np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 0.73577888, 0.73577888]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = covariance.grad_cov_main('matern32', np.ones((1, 2)), np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 0.59566154, 0.51802578]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = covariance.grad_cov_main('matern32', np.ones((1, 2)), np.zeros((1, 2)), cur_hyps, True)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.59566154, 0.51802578]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = covariance.grad_cov_main('matern52', np.ones((1, 2)), np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 0.63458673, 0.8305486]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
def _cov_main_vector(str_cov, num_dim, num_X, num_Xs):
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cov_ = covariance.cov_main(str_cov,
np.zeros((num_X, num_dim)),
np.zeros((num_Xs, num_dim)),
cur_hyps,
False,
jitter=0.001)
return cov_
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:
gp_common.get_kernel_inverse(1, hyps, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(np.arange(0, 100), hyps, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(X, 1, 'se')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(X, hyps, 1)
with pytest.raises(ValueError) as error:
gp_common.get_kernel_inverse(X, hyps, 'abc')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(X, hyps, 'se', debug=1)
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(X, hyps, 'se', is_gradient='abc')
with pytest.raises(AssertionError) as error:
gp_common.get_kernel_inverse(X, hyps, 'se', is_fixed_noise='abc')
cov_X_X, inv_cov_X_X, grad_cov_X_X = gp_common.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 = gp_common.get_kernel_inverse(
X, hyps, 'se', is_gradient=True, is_fixed_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, 3.70158953e-05, 3.70158953e-05, 3.70158953e-05],
[7.06525714e-24, 3.81523886e-22, 3.81523886e-22, 3.81523886e-22]],
[[2.74191817e-06, 3.70158953e-05, 3.70158953e-05, 3.70158953e-05],
[2.00002000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[2.74191817e-06, 3.70158953e-05, 3.70158953e-05, 3.70158953e-05]],
[[7.06525714e-24, 3.81523886e-22, 3.81523886e-22, 3.81523886e-22],
[2.74191817e-06, 3.70158953e-05, 3.70158953e-05, 3.70158953e-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_grad_cov_matern52():
str_cov = 'matern52'
cur_hyps = utils_covariance.get_hyps(str_cov, 2)
X_train = np.array([
[2.0, 1.0],
[1.0, 1.0],
])
num_hyps = X_train.shape[1] + 1
cov_ = covariance.cov_main(str_cov, X_train, X_train, cur_hyps, True)
print(cov_)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52('abc', X_train, X_train, cur_hyps, num_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52(cov_, 'abc', X_train, cur_hyps, num_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52(cov_, X_train, 'abc', cur_hyps, num_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52(cov_, X_train, X_train, 'abc', num_hyps, True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52(cov_, X_train, X_train, cur_hyps, 'abc', True)
with pytest.raises(AssertionError) as error:
covariance.grad_cov_matern52(cov_, X_train, X_train, cur_hyps, num_hyps, 'abc')
num_hyps = X_train.shape[1] + 2
grad_cov_ = covariance.grad_cov_matern52(cov_, X_train, X_train, cur_hyps, num_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([
[
[0.02, 2.00002, 0., 0.],
[0., 1.04798822, 0.57644039, 0.57644039],
], [
[0., 1.04798822, 0.57644039, 0.57644039],
[0.02, 2.00002, 0., 0.]
]
])
assert np.all(np.abs(truth_grad_cov_ - grad_cov_) < TEST_EPSILON)
num_hyps = X_train.shape[1] + 1
grad_cov_ = covariance.grad_cov_matern52(cov_, X_train, X_train, cur_hyps, num_hyps, True)
print(grad_cov_)
truth_grad_cov_ = np.array([
[
[2.00002, 0., 0.],
[1.04798822, 0.57644039, 0.57644039],
], [
[1.04798822, 0.57644039, 0.57644039],
[2.00002, 0., 0.]
]
])
assert np.all(np.abs(truth_grad_cov_ - grad_cov_) < TEST_EPSILON)
def test_validate_hyps_arr():
num_dim = 2
str_cov = 'matern32'
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps = utils_covariance.convert_hyps(str_cov,
cur_hyps,
is_fixed_noise=False)
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_arr(123, str_cov, num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_arr(
cur_hyps, 'abc', num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_arr(
cur_hyps, str_cov, 'abc')
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 test_log_ml():
dim_X = 3
str_cov = 'se'
X = np.reshape(np.arange(0, 9), (3, dim_X))
Y = np.expand_dims(np.arange(3, 10, 3), axis=1)
dict_hyps = utils_covariance.get_hyps(str_cov, dim_X)
arr_hyps = utils_covariance.convert_hyps(str_cov, dict_hyps, is_fixed_noise=constants.IS_FIXED_GP_NOISE)
prior_mu_X = np.zeros((3, 1))
with pytest.raises(AssertionError) as error:
gp.log_ml(np.arange(0, 3), Y, arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, np.arange(0, 3), arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, dict_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, 1, prior_mu_X)
with pytest.raises(ValueError) as error:
gp.log_ml(X, Y, arr_hyps, 'abc', prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, str_cov, np.arange(0, 3))
with pytest.raises(AssertionError) as error:
gp.log_ml(np.reshape(np.arange(0, 12), (4, dim_X)), Y, arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, np.expand_dims(np.arange(0, 4), axis=1), arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, str_cov, np.expand_dims(np.arange(0, 4), axis=1))
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, is_cholesky=1)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, is_fixed_noise=1)
with pytest.raises(AssertionError) as error:
gp.log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, debug=1)
log_ml = gp.log_ml(X, Y, arr_hyps, str_cov, prior_mu_X)
print(log_ml)
truth_log_ml = -65.74995266591506
assert np.abs(log_ml - truth_log_ml) < TEST_EPSILON
log_ml = gp.log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, is_cholesky=False)
print(log_ml)
truth_log_ml = -65.74995266566506
assert np.abs(log_ml - truth_log_ml) < TEST_EPSILON
def test_validate_hyps_arr():
num_dim = 2
str_cov = 'matern32'
cur_hyps = package_target.get_hyps(str_cov, num_dim)
cur_hyps = package_target.convert_hyps(str_cov, cur_hyps, fix_noise=False)
with pytest.raises(AssertionError) as error:
_, is_valid = package_target.validate_hyps_arr(123, str_cov, num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = package_target.validate_hyps_arr(cur_hyps, 'abc',
num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = package_target.validate_hyps_arr(cur_hyps, str_cov,
'abc')
with pytest.raises(AssertionError) as error:
_, is_valid = package_target.validate_hyps_arr(cur_hyps,
str_cov,
num_dim,
use_gp='abc')
def test_grad_cov_se():
str_cov = 'se'
cur_hyps = utils_covariance.get_hyps(str_cov, 2)
X_train = np.array([
[2.0, 1.0],
[1.0, 1.0],
])
num_hyps = X_train.shape[1] + 1
cov_ = package_target.cov_main(str_cov, X_train, X_train, cur_hyps, True)
print(cov_)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se('abc', X_train, X_train, cur_hyps, num_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se(cov_, 'abc', X_train, cur_hyps, num_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se(cov_, X_train, 'abc', cur_hyps, num_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se(cov_, X_train, X_train, 'abc', num_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se(cov_, X_train, X_train, cur_hyps, 'abc',
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_se(cov_, X_train, X_train, cur_hyps, num_hyps,
'abc')
num_hyps = X_train.shape[1] + 2
grad_cov_ = package_target.grad_cov_se(cov_, X_train, X_train, cur_hyps,
num_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[
[0.02, 2.00002, 0.0, 0.0],
[0., 1.21306132, 0.60653066, 0.0],
], [[0., 1.21306132, 0.60653066, 0.0], [0.02, 2.00002, 0.0, 0.0]]])
assert np.all(np.abs(truth_grad_cov_ - grad_cov_) < TEST_EPSILON)
def test_cov_se():
with pytest.raises(AssertionError) as error:
covariance.cov_se(np.zeros(2), np.zeros(2), np.array([1.0, 1.0, 1.0]),
0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_se(np.zeros(2), np.zeros(3), np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_se(np.zeros(3), np.zeros(2), np.array([1.0, 1.0]), 0.1)
with pytest.raises(AssertionError) as error:
covariance.cov_se(np.zeros(2), np.zeros(2), np.array([1.0, 1.0]), 1)
assert np.abs(
covariance.cov_se(np.zeros(2), np.zeros(2), 1.0, 0.1) -
0.01) < TEST_EPSILON
bx = np.array([1.0, 2.0, 0.0])
bxp = np.array([2.0, 1.0, 1.0])
cur_hyps = utils_covariance.get_hyps('se', 3)
cov_ = covariance.cov_se(bx, bxp, cur_hyps['lengthscales'],
cur_hyps['signal'])
print(cov_)
truth_cov_ = 0.22313016014842987
assert np.abs(cov_ - truth_cov_) < TEST_EPSILON
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 get_optimized_kernel(
X_train,
Y_train,
prior_mu,
str_cov,
str_optimizer_method=constants.STR_OPTIMIZER_METHOD_GP,
str_modelselection_method=constants.STR_MODELSELECTION_METHOD,
is_fixed_noise=constants.IS_FIXED_GP_NOISE,
debug=False):
"""
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: function 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 is_fixed_noise: flag for fixing a noise.
:type is_fixed_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 is_fixed_noise to convert_hyps and restore_hyps
assert isinstance(X_train, np.ndarray)
assert isinstance(Y_train, np.ndarray)
assert callable(prior_mu) or prior_mu is None
assert isinstance(str_cov, str)
assert isinstance(str_optimizer_method, str)
assert isinstance(str_modelselection_method, str)
assert isinstance(is_fixed_noise, bool)
assert isinstance(debug, bool)
assert len(Y_train.shape) == 2
assert X_train.shape[0] == Y_train.shape[0]
_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
# TODO: fix this.
is_gradient = True
time_start = time.time()
if debug:
print('[DEBUG] get_optimized_kernel in gp.py: str_optimizer_method {}'.
format(str_optimizer_method))
print(
'[DEBUG] get_optimized_kernel in gp.py: str_modelselection_method {}'
.format(str_modelselection_method))
prior_mu_train = get_prior_mu(prior_mu, X_train)
if str_cov in constants.ALLOWED_GP_COV_BASE:
num_dim = X_train.shape[1]
elif str_cov in constants.ALLOWED_GP_COV_SET:
num_dim = X_train.shape[2]
is_gradient = False
if str_modelselection_method == 'ml':
neg_log_ml_ = lambda hyps: neg_log_ml(X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
is_fixed_noise=is_fixed_noise,
is_gradient=is_gradient,
debug=debug)
elif str_modelselection_method == 'loocv':
neg_log_ml_ = lambda hyps: neg_log_pseudo_l_loocv(X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
is_fixed_noise=
is_fixed_noise,
debug=debug)
is_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),
is_fixed_noise=is_fixed_noise,
)
if str_optimizer_method == 'BFGS':
result_optimized = scipy.optimize.minimize(neg_log_ml_,
hyps_converted,
method=str_optimizer_method,
jac=is_gradient,
options={'disp': False})
result_optimized = result_optimized.x
elif str_optimizer_method == 'L-BFGS-B':
bounds = utils_covariance.get_range_hyps(str_cov,
num_dim,
is_fixed_noise=is_fixed_noise)
result_optimized = scipy.optimize.minimize(neg_log_ml_,
hyps_converted,
method=str_optimizer_method,
bounds=bounds,
jac=is_gradient,
options={'disp': False})
result_optimized = result_optimized.x
# TODO: Fill this conditions
elif str_optimizer_method == 'DIRECT': # pragma: no cover
raise NotImplementedError(
'get_optimized_kernel: allowed str_optimizer_method, but it is not implemented.'
)
elif str_optimizer_method == 'CMA-ES': # pragma: no cover
raise NotImplementedError(
'get_optimized_kernel: allowed str_optimizer_method, but it is not implemented.'
)
else: # pragma: no cover
raise ValueError(
'get_optimized_kernel: missing conditions for str_optimizer_method'
)
hyps = utils_covariance.restore_hyps(str_cov,
result_optimized,
is_fixed_noise=is_fixed_noise)
hyps, _ = utils_covariance.validate_hyps_dict(hyps, str_cov, num_dim)
cov_X_X, inv_cov_X_X, grad_cov_X_X = get_kernel_inverse(
X_train, hyps, str_cov, is_fixed_noise=is_fixed_noise, debug=debug)
time_end = time.time()
if debug:
print('[DEBUG] get_optimized_kernel in gp.py: optimized hyps for gpr',
hyps)
print('[DEBUG] get_optimized_kernel in gp.py: time consumed',
time_end - time_start, 'sec.')
return cov_X_X, inv_cov_X_X, hyps
def test_cov_main():
cur_hyps = utils_covariance.get_hyps('se', 3)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 2)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((20, 2)),
cur_hyps,
False,
jitter=0.001)
with pytest.raises(ValueError) as error:
covariance.cov_main('se',
np.zeros((10, 2)),
np.zeros((20, 2)),
cur_hyps,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
1.0,
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 2)),
1.0,
cur_hyps,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main(1.0,
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((20, 3)),
2.1,
False,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
'abc',
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((12, 3)),
cur_hyps,
True,
jitter=0.001)
with pytest.raises(AssertionError) as error:
covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=1)
with pytest.raises(AssertionError) as error:
covariance.cov_main('abc',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
cur_hyps.pop('signal', None)
with pytest.raises(ValueError) as error:
covariance.cov_main('se', np.zeros((10, 3)), np.zeros((20, 3)),
cur_hyps, False)
with pytest.raises(ValueError) as error:
covariance.cov_main('set_se', np.zeros((10, 5, 3)), np.zeros(
(20, 5, 3)), cur_hyps, False)
cur_hyps = utils_covariance.get_hyps('se', 3)
cov_ = covariance.cov_main('se',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cov_ = covariance.cov_main('set_se',
np.zeros((10, 5, 3)),
np.zeros((20, 5, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cur_hyps = utils_covariance.get_hyps('matern32', 3)
cov_ = covariance.cov_main('matern32',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cov_ = covariance.cov_main('set_matern32',
np.zeros((10, 5, 3)),
np.zeros((20, 5, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cov_ = covariance.cov_main('set_matern32',
np.zeros((10, 5, 3)),
np.zeros((10, 5, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 10)))
cov_ = covariance.cov_main('set_matern32',
np.zeros((10, 5, 3)),
np.zeros((10, 5, 3)),
cur_hyps,
True,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 10)) + np.eye(10) * 1e-3)
cur_hyps = utils_covariance.get_hyps('matern52', 3)
cov_ = covariance.cov_main('matern52',
np.zeros((10, 3)),
np.zeros((20, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cov_ = covariance.cov_main('set_matern52',
np.zeros((10, 5, 3)),
np.zeros((20, 5, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 20)))
cov_ = covariance.cov_main('set_matern52',
np.zeros((10, 5, 3)),
np.zeros((10, 5, 3)),
cur_hyps,
False,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 10)))
cov_ = covariance.cov_main('set_matern52',
np.zeros((10, 5, 3)),
np.zeros((10, 5, 3)),
cur_hyps,
True,
jitter=0.001)
assert np.all(cov_ == np.ones((10, 10)) + np.eye(10) * 1e-3)
def test_validate_hyps_dict():
num_dim = 2
str_cov = 'matern32'
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps.pop('noise')
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, 'abc', num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps.pop('lengthscales')
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps.pop('signal')
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps['noise'] = 'abc'
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps['noise'] = np.inf
cur_hyps, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert cur_hyps['noise'] == constants.BOUND_UPPER_GP_NOISE
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, 123)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps['lengthscales'] = 'abc'
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
cur_hyps = utils_covariance.get_hyps(str_cov, num_dim)
cur_hyps['signal'] = 'abc'
with pytest.raises(AssertionError) as error:
_, is_valid = utils_covariance.validate_hyps_dict(
cur_hyps, str_cov, num_dim)
assert is_valid == True
def test_get_hyps():
with pytest.raises(AssertionError) as error:
utils_covariance.get_hyps(1.2, 2.1)
with pytest.raises(AssertionError) as error:
utils_covariance.get_hyps(1.2, 2)
with pytest.raises(AssertionError) as error:
utils_covariance.get_hyps('se', 2.1)
with pytest.raises(AssertionError) as error:
utils_covariance.get_hyps('abc', 2)
with pytest.raises(AssertionError) as error:
utils_covariance.get_hyps('se', 2, is_ard='abc')
cur_hyps = utils_covariance.get_hyps('se', 2)
assert cur_hyps['noise'] == constants.GP_NOISE
assert cur_hyps['signal'] == 1.0
assert len(cur_hyps['lengthscales'].shape) == 1
assert (cur_hyps['lengthscales'] == np.array([1.0, 1.0])).all()
cur_hyps = utils_covariance.get_hyps('se', 2, is_ard=False)
assert cur_hyps['noise'] == constants.GP_NOISE
assert cur_hyps['signal'] == 1.0
assert cur_hyps['lengthscales'] == 1.0
cur_hyps = utils_covariance.get_hyps('matern32', 2, is_ard=False)
assert cur_hyps['noise'] == constants.GP_NOISE
assert cur_hyps['signal'] == 1.0
assert cur_hyps['lengthscales'] == 1.0
cur_hyps = utils_covariance.get_hyps('matern52', 2, is_ard=False)
assert cur_hyps['noise'] == constants.GP_NOISE
assert cur_hyps['signal'] == 1.0
assert cur_hyps['lengthscales'] == 1.0
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_neg_log_ml():
dim_X = 3
str_cov = 'se'
X = np.reshape(np.arange(0, 9), (3, dim_X))
Y = np.expand_dims(np.arange(3, 10, 3), axis=1)
is_fixed_noise = False
dict_hyps = utils_covariance.get_hyps(str_cov, dim_X)
arr_hyps = utils_covariance.convert_hyps(str_cov,
dict_hyps,
is_fixed_noise=is_fixed_noise)
prior_mu_X = np.zeros((3, 1))
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(np.arange(0, 3), Y, arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, np.arange(0, 3), arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, dict_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, 1, prior_mu_X)
with pytest.raises(ValueError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, 'abc', prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, str_cov, np.arange(0, 3))
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(np.reshape(np.arange(0, 12), (4, dim_X)), Y,
arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, np.expand_dims(np.arange(0, 4), axis=1),
arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, str_cov,
np.expand_dims(np.arange(0, 4), axis=1))
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, is_cholesky=1)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
is_fixed_noise=1)
with pytest.raises(AssertionError) as error:
gp_scipy.neg_log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, debug=1)
neg_log_ml_ = gp_scipy.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
is_fixed_noise=is_fixed_noise,
is_gradient=False,
is_cholesky=True)
print(neg_log_ml_)
truth_log_ml_ = 21.916650988532854
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
neg_log_ml_ = gp_scipy.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
is_fixed_noise=is_fixed_noise,
is_gradient=False,
is_cholesky=False)
print(neg_log_ml_)
truth_log_ml_ = 21.91665090519953
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
neg_log_ml_ = gp_scipy.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
is_fixed_noise=is_fixed_noise,
is_gradient=True,
is_cholesky=False)
print(neg_log_ml_)
truth_log_ml_ = 21.91665090519953
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
neg_log_ml_, neg_grad_log_ml_ = gp_scipy.neg_log_ml(
X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
is_fixed_noise=is_fixed_noise,
is_gradient=True,
is_cholesky=True)
print(neg_log_ml_)
print(neg_grad_log_ml_)
truth_log_ml_ = 21.916650988532854
truth_grad_log_ml_ = np.array([
-4.09907399e-01,
-4.09912156e+01,
-8.88182458e-04,
-8.88182458e-04,
-8.88182458e-04,
])
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
assert np.all(np.abs(neg_grad_log_ml_ - truth_grad_log_ml_) < TEST_EPSILON)
def get_optimized_kernel(
X_train,
Y_train,
prior_mu,
str_cov,
str_optimizer_method=constants.STR_OPTIMIZER_METHOD_GP,
str_modelselection_method=constants.STR_MODELSELECTION_METHOD,
is_fixed_noise=constants.IS_FIXED_GP_NOISE,
debug=False):
# TODO: check to input same is_fixed_noise to convert_hyps and restore_hyps
assert isinstance(X_train, np.ndarray)
assert isinstance(Y_train, np.ndarray)
assert callable(prior_mu) or prior_mu is None
assert isinstance(str_cov, str)
assert isinstance(str_optimizer_method, str)
assert isinstance(str_modelselection_method, str)
assert isinstance(is_fixed_noise, bool)
assert isinstance(debug, bool)
assert len(Y_train.shape) == 2
assert X_train.shape[0] == Y_train.shape[0]
_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
time_start = time.time()
if debug:
print('[DEBUG] get_optimized_kernel in gp.py: str_optimizer_method {}'.
format(str_optimizer_method))
print(
'[DEBUG] get_optimized_kernel in gp.py: str_modelselection_method {}'
.format(str_modelselection_method))
prior_mu_train = get_prior_mu(prior_mu, X_train)
if str_cov in constants.ALLOWED_GP_COV_BASE:
num_dim = X_train.shape[1]
elif str_cov in constants.ALLOWED_GP_COV_SET:
num_dim = X_train.shape[2]
if str_modelselection_method == 'ml':
neg_log_ml = lambda hyps: -1.0 * log_ml(X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
is_fixed_noise=is_fixed_noise,
debug=debug)
elif str_modelselection_method == 'loocv':
neg_log_ml = lambda hyps: -1.0 * log_pseudo_l_loocv(X_train,
Y_train,
hyps,
str_cov,
prior_mu_train,
is_fixed_noise=
is_fixed_noise,
debug=debug)
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),
is_fixed_noise=is_fixed_noise,
)
if str_optimizer_method == 'BFGS':
result_optimized = scipy.optimize.minimize(neg_log_ml,
hyps_converted,
method=str_optimizer_method)
result_optimized = result_optimized.x
elif str_optimizer_method == 'L-BFGS-B':
bounds = utils_covariance.get_range_hyps(str_cov,
num_dim,
is_fixed_noise=is_fixed_noise)
result_optimized = scipy.optimize.minimize(neg_log_ml,
hyps_converted,
method=str_optimizer_method,
bounds=bounds)
result_optimized = result_optimized.x
# TODO: Fill this conditions
elif str_optimizer_method == 'DIRECT': # pragma: no cover
raise NotImplementedError(
'get_optimized_kernel: allowed str_optimizer_method, but it is not implemented.'
)
elif str_optimizer_method == 'CMA-ES': # pragma: no cover
raise NotImplementedError(
'get_optimized_kernel: allowed str_optimizer_method, but it is not implemented.'
)
# INFO: It is allowed, but a condition is missed.
else: # pragma: no cover
raise ValueError(
'get_optimized_kernel: missing conditions for str_optimizer_method'
)
hyps = utils_covariance.restore_hyps(str_cov,
result_optimized,
is_fixed_noise=is_fixed_noise)
hyps, _ = utils_covariance.validate_hyps_dict(hyps, str_cov, num_dim)
cov_X_X, inv_cov_X_X = get_kernel_inverse(X_train,
hyps,
str_cov,
debug=debug)
time_end = time.time()
if debug:
print('[DEBUG] get_optimized_kernel in gp.py: optimized hyps for gpr',
hyps)
print('[DEBUG] get_optimized_kernel in gp.py: time consumed',
time_end - time_start, 'sec.')
return cov_X_X, inv_cov_X_X, hyps
def test_grad_cov_main():
cur_hyps = utils_covariance.get_hyps('se', 2)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main(123, np.zeros((10, 2)), np.zeros((10, 2)),
cur_hyps, True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se', 123, np.zeros((10, 2)), cur_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se', np.zeros((10, 2)), 123, cur_hyps,
True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se', np.zeros((10, 2)), np.zeros(
(10, 2)), 123, True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se', np.zeros((10, 2)), np.zeros(
(10, 2)), cur_hyps, 'abc')
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('abc', np.zeros((10, 2)), np.zeros(
(10, 2)), cur_hyps, True)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se',
np.zeros((10, 2)),
np.zeros((10, 2)),
cur_hyps,
True,
same_X_Xp='abc')
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se',
np.zeros((10, 2)),
np.zeros((10, 2)),
cur_hyps,
True,
same_X_Xp=False)
with pytest.raises(AssertionError) as error:
package_target.grad_cov_main('se',
np.zeros((10, 2)),
np.zeros((10, 2)),
cur_hyps,
True,
jitter='abc')
grad_cov_ = package_target.grad_cov_main('se', np.ones((1, 2)),
np.ones((1, 2)), cur_hyps, True)
print(grad_cov_)
truth_grad_cov_ = np.array([[[2.00002, 0.0, 0.0]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = package_target.grad_cov_main('se', np.ones((1, 2)),
np.ones((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 2.00002, 0.0, 0.0]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
cur_hyps['lengthscales'] = 1.0
grad_cov_ = package_target.grad_cov_main('se', np.ones((1, 2)),
np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 0.73577888, 0.73577888]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = package_target.grad_cov_main('matern32', np.ones((1, 2)),
np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.02, 0.59566154, 0.51802578]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = package_target.grad_cov_main('matern32', np.ones((1, 2)),
np.zeros((1, 2)), cur_hyps, True)
print(grad_cov_)
truth_grad_cov_ = np.array([[[0.59566154, 0.51802578]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < TEST_EPSILON)
grad_cov_ = package_target.grad_cov_main('matern52', np.ones((1, 2)),
np.zeros((1, 2)), cur_hyps, False)
print(grad_cov_)
print(np.squeeze(grad_cov_)[0])
print(np.squeeze(grad_cov_)[1])
print(np.squeeze(grad_cov_)[2])
truth_grad_cov_ = np.array(
[[[0.02, 0.6345867279080876, 0.5872865507000906]]])
assert np.all(np.abs(grad_cov_ - truth_grad_cov_) < 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 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_neg_log_ml():
dim_X = 3
str_cov = 'se'
X = np.reshape(np.arange(0, 9), (3, dim_X))
Y = np.expand_dims(np.arange(3, 10, 3), axis=1)
fix_noise = False
use_gp = False
dict_hyps = utils_covariance.get_hyps(str_cov, dim_X, use_gp=use_gp)
arr_hyps = utils_covariance.convert_hyps(str_cov,
dict_hyps,
fix_noise=fix_noise,
use_gp=use_gp)
prior_mu_X = np.zeros((3, 1))
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(np.arange(0, 3), Y, arr_hyps, str_cov,
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, np.arange(0, 3), arr_hyps, str_cov,
prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, Y, dict_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, Y, arr_hyps, 1, prior_mu_X)
with pytest.raises(ValueError) as error:
package_target.neg_log_ml(X, Y, arr_hyps, 'abc', prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, Y, arr_hyps, str_cov, np.arange(0, 3))
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(np.reshape(np.arange(0, 12), (4, dim_X)), Y,
arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, np.expand_dims(np.arange(0, 4), axis=1),
arr_hyps, str_cov, prior_mu_X)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, Y, arr_hyps, str_cov,
np.expand_dims(np.arange(0, 4), axis=1))
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
fix_noise=1)
with pytest.raises(AssertionError) as error:
package_target.neg_log_ml(X, Y, arr_hyps, str_cov, prior_mu_X, debug=1)
neg_log_ml_ = package_target.neg_log_ml(X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
fix_noise=fix_noise,
use_gradient=False)
print(neg_log_ml_)
truth_log_ml_ = 5.634155417555853
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
neg_log_ml_, neg_grad_log_ml_ = package_target.neg_log_ml(
X,
Y,
arr_hyps,
str_cov,
prior_mu_X,
fix_noise=fix_noise,
use_gradient=True)
print(neg_log_ml_)
print(neg_grad_log_ml_)
print(neg_grad_log_ml_[2])
print(neg_grad_log_ml_[3])
print(neg_grad_log_ml_[4])
truth_log_ml_ = 5.634155417555853
truth_grad_log_ml_ = np.array([
-1.60446383e-02,
1.75087448e-01,
-1.60448396e+00,
-1.836237221888097e-05,
-1.836237221888097e-05,
-1.836237221888097e-05,
])
assert np.abs(neg_log_ml_ - truth_log_ml_) < TEST_EPSILON
assert np.all(np.abs(neg_grad_log_ml_ - truth_grad_log_ml_) < TEST_EPSILON)
dict_hyps = utils_covariance.get_hyps(str_cov, dim_X, use_gp=use_gp)
arr_hyps = utils_covariance.convert_hyps(str_cov,
dict_hyps,
fix_noise=True,
use_gp=use_gp)
neg_log_ml_, neg_grad_log_ml_ = package_target.neg_log_ml(
X, Y, arr_hyps, str_cov, prior_mu_X, fix_noise=True, use_gradient=True)
print(neg_log_ml_)
print(neg_grad_log_ml_)
