def compute_posterior_params(self,
gp_model,
kernel_params,
mean_parameters=None,
weights=None):
## Mean is zero. We may need to change when including mean
##Compute posterior parameters of f(x*)
f = self.function_factor_kernel
g = self.divisor_kernel
current_point = [gp_model.current_iteration]
X_data = gp_model.data['points']
vector_ = self.cov_diff_point(gp_model, kernel_params, current_point,
X_data)
cov = self.covariance_diff_kernel(gp_model, X_data, kernel_params)
chol = cholesky(cov, max_tries=7)
if self.parametric_mean:
mean = self.compute_parametric_mean(gp_model, weights,
mean_parameters)
prior_mean = self.parametrics.weighted_combination(
current_point[0], weights, mean_parameters)
else:
mean = 0.
prior_mean = 0.
y_unbiased = gp_model.data['evaluations'] - mean
solve = cho_solve(chol, y_unbiased)
part_2 = cho_solve(chol, vector_)
if self.model_gradient == 'real_gradient':
grad = np.array(gp_model.raw_results['gradients'][-1])
elif self.model_gradient == 'grad_epoch':
grad = np.array(
gp_model.raw_results['gradients'][gp_model.current_iteration -
1])
mean = gp_model.raw_results['values'][-1][0] - \
grad * (np.dot(vector_, solve) + prior_mean) \
/ np.sqrt(gp_model.current_iteration)
raw_cov = gp_model.kernel.evaluate_cov_defined_by_params(
kernel_params, np.array([current_point]), 1)
var = raw_cov - np.dot(vector_, part_2)
var *= (grad**2) / (float(gp_model.current_iteration))
return mean[0], var[0, 0]
def ei_given_sample(self, sample, parameters_kernel, candidate_point):
"""
Correct
See p. 1140. We compute (8)
:param sample:
:param parameters_kernel:
:param candidate_point:
:return:
"""
M = np.min(sample)
n = len(sample)
mc, c, chol, Z, bc = self.compute_mc_given_sample(
sample, candidate_point, parameters_kernel)
historical_points = self.gp.data['points']
candidate_vector = np.zeros(
(len(self.domain_xe), historical_points.shape[1]))
for j in range(len(self.domain_xe)):
point = np.concatenate(
(candidate_point, np.array(self.domain_xe[j])))
candidate_vector[j, :] = point
cov_new = self.gp.evaluate_cov(candidate_vector, parameters_kernel)
weights_matrix = self.weights.reshape((len(self.weights), 1))
Rc = np.dot(weights_matrix.transpose(), np.dot(cov_new,
weights_matrix))
Rc -= np.dot(c, cho_solve(chol, c.transpose()))
one = np.ones((2 * n, 1))
Rc += (1 - np.dot(c, cho_solve(chol, one))) ** 2 / \
(np.dot(one.transpose(), cho_solve(chol, one)))
Zc = Z.reshape((len(Z), 1))
sigma_c = np.dot(Zc.transpose(), cho_solve(chol, Zc))
sigma_c -= (bc**2) * np.dot(one.transpose(), cho_solve(chol, one))
sigma_c /= (2.0 * n - 1)
difference = M - mc
sd = 1.0 / np.sqrt(Rc * sigma_c)
component_1 = (M - mc) * t.cdf(difference * sd, 2 * n - 1)
component_2 = t.pdf(difference * sd, 2 * n - 1)
component_2 *= 1.0 / (2.0 * (n - 1))
component_2 *= (2.0 * n - 1) * np.sqrt(Rc * sigma_c) + (difference**
2) * sd
result = component_1 + component_2
return result[0, 0]
def compute_expectation_sample(self, parameters_kernel):
"""
Correct
:param parameters_kernel:
:return:
"""
historical_points = self.gp.data['points']
var, beta = self.estimate_variance_gp(parameters_kernel)
y = self.gp.data['evaluations']
n = len(y)
z = np.ones(n)
create_vector = np.zeros(
(historical_points.shape[0] * len(self.domain_xe), historical_points.shape[1]))
for i in range(historical_points.shape[0]):
for j in range(len(self.domain_xe)):
first_part = historical_points[i][0:self.x_domain]
point = np.concatenate((first_part, np.array(self.domain_xe[j])))
create_vector[(i-1)*len(self.domain_xe) + j, :] = point
cov = self.gp.evaluate_cov(historical_points, parameters_kernel)
chol = cholesky(cov, max_tries=7)
matrix_cov = self.gp.kernel.evaluate_cross_cov_defined_by_params(
parameters_kernel, self.gp.data['points'], create_vector, historical_points.shape[1])
matrix_cov = np.dot(
matrix_cov, np.kron(np.identity(n), self.weights.reshape((len(self.weights),1))))
vect = y - beta * z
vect = vect.reshape((len(vect), 1))
solve = np.dot(matrix_cov.transpose() ,cho_solve(chol, vect))
sample = np.ones((n, 1)) * beta + solve
return sample
def log_likelihood(self,
gp_model,
parameters_kernel,
mean_parameters=None,
weights=None):
"""
GP log likelihood: y(x) ~ f(x) + epsilon, where epsilon(x) are iid N(0,var_noise), and
f(x) ~ GP(mean, cov)
:param var_noise: (float) variance of the noise
:param mean: (float)
:param parameters_kernel: np.array(k), The order of the parameters is given in the
definition of the class kernel.
:return: float
"""
X_data = gp_model.data['points']
cov = self.covariance_diff_kernel(gp_model, X_data, parameters_kernel)
chol = cholesky(cov, max_tries=7)
if self.parametric_mean:
mean = self.compute_parametric_mean(gp_model, weights,
mean_parameters)
else:
mean = 0
y_unbiased = gp_model.data['evaluations'] - mean
solve = cho_solve(chol, y_unbiased)
return -np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(y_unbiased, solve)
def compute_posterior_params(self, gp_model, kernel_params, mean_parameters=None, weights=None):
## Mean is zero. We may need to change when including mean
##Compute posterior parameters of f(x*)
f = self.function_factor_kernel
g = self.divisor_kernel
current_point = [gp_model.current_iteration]
X_data = gp_model.data['points']
vector_ = self.cov_diff_point(gp_model, kernel_params, current_point, X_data)
cov = self.covariance_diff_kernel(gp_model, X_data, kernel_params)
chol = cholesky(cov, max_tries=7)
if self.parametric_mean:
mean = self.compute_parametric_mean(gp_model, weights, mean_parameters)
prior_mean = self.parametrics.weighted_combination(
current_point[0], weights, mean_parameters) / f(current_point[0])
else:
mean = 0.
prior_mean = 0.
y_unbiased = gp_model.data['evaluations'] - mean
solve = cho_solve(chol, y_unbiased)
part_2 = cho_solve(chol, vector_)
mean = gp_model.raw_results[-1] + np.dot(vector_, solve) + prior_mean
raw_cov = gp_model.kernel.evaluate_cov_defined_by_params(
kernel_params, np.array([current_point]), 1) / \
g(f(current_point[0]), f(current_point[0]))
var = raw_cov - np.dot(vector_, part_2)
return mean, var
def test_cho_solve(self):
chol = cholesky(self.cov)
y = np.linspace(1.0, 100.0, self.cov.shape[0])
sol = cho_solve(chol, y)
npt.assert_almost_equal(np.dot(self.cov, sol), y)