def gp0(self, m, s):
"""
Compute joint predictions for MGP with uncertain inputs.
"""
assert hasattr(self, "hyp")
if not hasattr(self, "K"):
self.cache()
x = np.atleast_2d(self.inputs)
y = np.atleast_2d(self.targets)
n, D = x.shape
n, E = y.shape
X = self.hyp
iK = self.iK
beta = self.alpha
m = np.atleast_2d(m)
inp = x - m
# Compute the predicted mean and IO covariance.
iL = np.stack([np.diag(exp(-X[i, :D])) for i in range(E)])
iN = np.matmul(inp, iL)
B = iL @ s @ iL + np.eye(D)
t = np.stack([solve(B[i].T, iN[i].T).T for i in range(E)])
q = exp(-np.sum(iN * t, 2) / 2)
qb = q * beta.T
tiL = np.matmul(t, iL)
c = exp(2 * X[:, D]) / sqrt(det(B))
M = np.sum(qb, 1) * c
V = (np.transpose(tiL, [0, 2, 1]) @ np.expand_dims(qb, 2)).reshape(
E, D).T * c
k = 2 * X[:, D].reshape(E, 1) - np.sum(iN**2, 2) / 2
# Compute the predicted covariance.
inp = np.expand_dims(inp, 0) / np.expand_dims(exp(2 * X[:, :D]), 1)
ii = np.repeat(inp[:, newaxis, :, :], E, 1)
ij = np.repeat(inp[newaxis, :, :, :], E, 0)
iL = np.stack([np.diag(exp(-2 * X[i, :D])) for i in range(E)])
siL = np.expand_dims(iL, 0) + np.expand_dims(iL, 1)
R = np.matmul(s, siL) + np.eye(D)
t = 1 / sqrt(det(R))
iRs = np.stack(
[solve(R.reshape(-1, D, D)[i], s) for i in range(E * E)])
iRs = iRs.reshape(E, E, D, D)
Q = exp(k[:, newaxis, :, newaxis] + k[newaxis, :, newaxis, :] +
maha(ii, -ij, iRs / 2))
S = np.einsum('ji,iljk,kl->il', beta, Q, beta)
tr = np.hstack([np.sum(Q[i, i] * iK[i]) for i in range(E)])
S = (S - np.diag(tr)) * t + np.diag(exp(2 * X[:, D]))
S = S - np.matmul(M[:, newaxis], M[newaxis, :])
return M, S, V
def gaussian_init(mu_in, var_in):
# single Gaussian
mu, var = mu_in, var_in
d = len(mu)
if d == 1:
def log_gaussian(x):
log_p_const = -0.5 * np.log(2 * PI) - 0.5 * np.log(var)
sub_mu = x - mu
return log_p_const - 0.5 * sub_mu * sub_mu / var
def generator(size):
return npr.normal(mu, np.sqrt(var), size)
else:
var_det, var_inv = linalg.det(var), linalg.inv(var)
log_p_const = -(d / 2.) * np.log(2 * PI) - 0.5 * np.log(var_det)
def log_gaussian(x):
sub_mu = x - mu
#out = log_p_const - 0.5*np.sum(np.multiply(sub_mu,np.dot(var_inv,sub_mu.T).T ),1)
out = log_p_const - 0.5 * np.sum(
np.multiply(sub_mu, np.dot(sub_mu, var_inv.T)), 1)
return out
def generator(size):
return npr.multivariate_normal(mu, var, size)
return log_gaussian, generator
def gen_point_source_psf_image(pixel_grid, image, loc,
psf_weights, psf_means, psf_covars):
# use image PSF
icovs = np.array([npla.inv(c) for c in psf_covars])
dets = np.array([npla.det(c) for c in psf_covars])
chols = np.array([npla.cholesky(c) for c in psf_covars])
return mog_like(pixel_grid, psf_means, icovs, dets, psf_weights)
def loss_sat(self, m, s):
D = len(m)
W = self.W if hasattr(self, 'W') else np.eye(D)
z = self.z if hasattr(self, 'z') else np.zeros(D)
m, z = np.atleast_2d(m), np.atleast_2d(z)
sW = np.dot(s, W)
ispW = solve((np.eye(D) + sW).T, W.T).T
L = -exp(-(m - z) @ ispW @ (m - z).T / 2) / sqrt(det(np.eye(D) + sW))
i2spW = solve((np.eye(D) + 2 * sW).T, W.T).T
r2 = exp(-(m - z) @ i2spW @ (m - z).T) / sqrt(det(np.eye(D) + 2 * sW))
S = r2 - L**2
t = np.dot(W, z.T) - ispW @ (np.dot(sW, z.T) + m.T)
C = L * t
return L + 1, S, C
def update_params(self, means, covs, pis):
assert covs.shape[1] == covs.shape[2] == self.D
assert self.K == covs.shape[0] == len(pis), "%d != %d != %d"%(self.K, covs.shape[0], len(pis))
#assert np.isclose(np.sum(pis), 1.)
self.means = means
self.covs = covs
self.pis = pis
self.dets = np.array([npla.det(c) for c in self.covs])
self.icovs = np.array([npla.inv(c) for c in self.covs])
self.chols = np.array([npla.cholesky(c) for c in self.covs])
def logPostFA(W, params):
X = params['data']
N = X.shape[0]
D, K = W.shape
Q = np.dot(W, W.T) + np.eye(D) * .1
log_prior = D * K * params['a'] * np.log(params['b']) - D * K * np.log(
gammaFn(params['a'])) + np.sum(
(params['a'] - 1) * np.log(W)) - np.sum(params['b'] * W)
return N / 2. * np.log(det(Q)) - .5 * trace(np.dot(np.dot(X.T, X),
inv(Q))) + log_prior
def obj_common(lam, alpha):
# 0th order
ret_val = (log_likelihood(y, X, w_map, model, lam) +
log_prior(w_map, alpha))[0]
# 2nd order
#ret_val += 0.5*w_map.shape[0]*ln_two_pi # not related to optimization
temp_mat2 = lam[0] * hesse_ses[0]
for i in range(1, dimy):
temp_mat2 += lam[i] * hesse_ses[i]
det_hesse = LA.det(temp_mat2 + alpha[0] * np.eye(w_map.shape[0]) +
temp_diag)
ret_val -= 0.5 * np.log(det_hesse)
return -ret_val
def kl_estimate(params,
layer_sizes,
n_data,
N_samples,
act='rbf',
kernel='rbf',
noise=1e-7):
x = np.random.uniform(-10, 10, size=(n_data, 1))
y = sample_bnn(params, x, N_samples, layer_sizes, act) # [nf, nd]
covariance = kernel_dict[kernel]
cov = covariance(x, x) + noise * np.eye(x.shape[0])
print(cov, y.shape, det(cov))
log_gp = log_gp_prior(y, cov)
#log_gp = mvn.logpdf(y, np.zeros(y.shape[1]), cov)
return -entropy_estimate(y) - np.mean(log_gp)
def gen_prof_mog_params(image, loc,
gal_sig, gal_rho, gal_phi,
psf_weights, psf_means, psf_covars,
prof_amp, prof_sig):
v_s = image.equa2pixel(loc)
R = galaxies.gen_galaxy_transformation(gal_sig, gal_rho, gal_phi)
W = np.dot(R, R.T)
K_psf = psf_weights.shape[0]
K_prof = prof_amp.shape[0]
# compute MOG components
num_components = K_psf * K_prof
weights = np.zeros(num_components, dtype=np.float)
means = np.zeros((num_components, 2), dtype=np.float)
covars = np.zeros((num_components, 2, 2), dtype=np.float)
cnt = 0
for k in range(K_psf): # num PSF Componenets
for j in range(K_prof): # galaxy type components
## compute weights and component mean/variances
weights[cnt] = psf_weights[k] * prof_amp[j]
## compute means
means[cnt,0] = v_s[0] + psf_means[k, 0]
means[cnt,1] = v_s[1] + psf_means[k, 1]
## compute covariance matrices
for ii in range(2):
for jj in range(2):
covars[cnt, ii, jj] = psf_covars[k, ii, jj] + \
prof_sig[j] * W[ii, jj]
# increment index
cnt += 1
icovs = np.array([npla.inv(c) for c in covars])
dets = np.array([npla.det(c) for c in covars])
chols = np.array([npla.cholesky(c) for c in covars])
return means, covars, icovs, dets, chols, weights
def approximate_log_marginal_likelihood(y, X, w_map, model, lam, alpha):
# see supplementary manuscript for details
log_ml = log_likelihood(y, X, w_map, model, lam) + log_prior(w_map, alpha)
log_ml += 0.5 * w_map.shape[0] * ln_two_pi
log_ml -= 0.5 * np.log(LA.det(hesse_w(y, X, w_map, model, lam, alpha)))
return np.array(log_ml)
def forward(self, argument, device=None, output_to_retain=None):
return argument, LA.det(argument)
def log_wishart(lam, W, nu, d=2):
# default dimensionality = 2
lognum1 = ((nu - d - 1) / 2) * np.log(det(lam))
lognum2 = -np.trace(np.dot(inv(W), lam)) / 2
logden1 = (nu * d / 2) * np.log(2) + (nu / 2) * np.log(det(W))
return lognum1 + lognum2 - logden1 - multigammaln(nu / 2, d)
def E_ln_lam_k(k, nu, W):
return np.sum(digamma(nu[k] + 1 - np.arange(D) +
1)) + D * np.log(2) + np.log(det(W[k]))
def ln_B(W, nu):
ln_num = -0.5 * nu * np.log(det(W))
ln_det_1 = 0.5 * nu * D * np.log(2) - D * (D - 1) * 0.25 * np.log(np.pi)
ln_det_2 = np.sum(gammaln(np.array([0.5 * (nu + 1 - i)
for i in range(D)])))
return ln_num - ln_det_1 - ln_det_2
def multivariate_gaussian_entropy(cov_sqrt):
cov = np.dot(cov_sqrt, cov_sqrt.T)
return 0.5 * cov.shape[0] * np.log(2*np.pi*np.exp(1)) + 0.5*np.log(det(cov))
