def __init__(self, x, xp, y, Sigmay=None, covariance_function='sqexp'):
"""
:param x: an array of arrays holding inputs i.e. x = [[x_1], [x_2], ..., [x_3]] where x_1 in R^{N_1} etc.
:param xp: an array of arrays holding targets i.e. xp = [[xp_1], [xp_2], ..., [xp_3]] where xp_1 in R^{Np_1} etc.
:param y: an array of arrays holding data i.e. y = [[y_1], [y_2], ..., [y_3]] where y_1 in R^{N_1} etc.
:param Sigmay: an array of arrays holding variances i.e. Sigmay = [[Sigmay_1], [Sigmay_2], ..., [Sigmay_3]]
where Sigmay_1 in R^{N_1} etc.
:param covariance_function: a list holding the covariance functions to use for each dimension
"""
self.D = x.shape[0]
self.N = kt.kron_N(x)
self.x = x
self.Np = kt.kron_N(xp)
self.xp = xp
self.y = y
if Sigmay is not None:
self.Sigmay = Sigmay
else:
self.Sigmay = None
self.covariance_function = covariance_function
# initialise the individual diff square grids
self.XX = []
self.XXp = []
self.XXpp = []
for i in xrange(self.D):
self.XX.append(abs_diff.abs_diff(self.x[i], self.x[i]))
self.XXp.append(abs_diff.abs_diff(self.x[i], self.xp[i]))
self.XXpp.append(abs_diff.abs_diff(self.xp[i], self.xp[i]))
self.XX = np.asarray(self.XX)
self.XXp = np.asarray(self.XXp)
self.XXpp = np.asarray(self.XXpp)
# set the kernels
from GP.kernels import exponential_squared # only using this one for now
self.kernels = []
self.kernels_transformed = []
for i in xrange(self.D):
if self.Sigmay is not None:
self.kernels.append(exponential_squared.sqexp(Sigmay=self.Sigmay[i], mode='kron'))
#self.kernels_transformed.append(exponential_squared.sqexp(mode='kron'))
else:
self.kernels.append(exponential_squared.sqexp(mode='kron'))
# Instantiate posterior mean, cov and evidence classes
self.meano = posterior_mean.meanf(self.x, self.xp, self.y, self.kernels, mode="kron",
XX=self.XX, XXp=self.XXp)
self.meanf = lambda theta: self.meano.give_mean(theta)
self.covo = posterior_covariance.covf(self.kernels, mode="kron", XX=self.XX, XXp=self.XXp, XXpp=self.XXpp)
self.covf = lambda theta: self.covo.give_covariance(theta)
self.logpo = marginal_posterior.evidence(self.x, self.y, self.kernels, mode="kron", XX=self.XX)
self.logp = lambda theta: self.logpo.logL(theta)
def __init__(self, x, xp, y, theta, Sigmay=None, kernels=['sqexp']):
"""
:param x: an array of arrays holding inputs i.e. x = [[x_1], [x_2], ..., [x_3]] where x_1 in R^{N_1} etc.
:param xp: an array of arrays holding targets i.e. xp = [[xp_1], [xp_2], ..., [xp_3]] where xp_1 in R^{Np_1} etc.
:param y: an array of arrays holding data i.e. y = [[y_1], [y_2], ..., [y_3]] where y_1 in R^{N_1} etc.
:param Sigmay: an array of arrays holding variances i.e. Sigmay = [[Sigmay_1], [Sigmay_2], ..., [Sigmay_3]]
where Sigmay_1 in R^{N_1} etc.
:param covariance_function: a list holding the covariance functions to use for each dimension
"""
self.D = x.shape[0]
self.N = y.size
self.x = x
self.Np = kt.kron_N(xp)
self.xp = xp
self.y = y.flatten()
# instantiate
self.theta = theta
self.kernels = kernels
self.Kop = covariance_ops.K_op(x, theta, kernels)
self.Kyop = covariance_ops.Ky_op(self.Kop, Sigmay)
# Instantiate posterior mean, cov and evidence classes
# self.meano = posterior_mean.meanf(self.x, self.xp, self.y, self.kernels, mode="kron",
# XX=self.XX, XXp=self.XXp)
# self.meanf = lambda theta: self.meano.give_mean(theta)
# self.covo = posterior_covariance.covf(self.kernels, mode="kron", XX=self.XX, XXp=self.XXp, XXpp=self.XXpp)
# self.covf = lambda theta: self.covo.give_covariance(theta)
self.logpo = marginal_posterior.evidence_op(self.y, self.Kyop)
def __init__(self, x, xp, y, kernel, Sigmay=None, mode="Full", prior_mean=None, XX=None, XXp=None, Phi=None, Phip=None, \
PhiTPhi = None, s=None, grid_regular=False):
"""
:param x: N x D vector of inputs
:param xp: Np x D vector of targets
:param y: the data
:param kernel: a class holding the covariance function and spectral densities
:param mode: whether to use full or RR GPR
:param prior_mean: callable prior mean function
:param XX: absolute differences of inputs
:param XXp: absolute differences between targets and inputs
:param Phi: basis functions evaluated at x
:param Phip: basis functions evaluated at xp
:param PhiTPhi: the product dot(Phi.T, Phi)
:param s: square root of eigenvalues
:param grid_regular: whether x is on a regular grid or not
"""
self.x = x
self.xp = xp
self.mode = mode
if self.mode != "kron":
self.N = self.x.shape[0]
self.Np = xp.shape[0]
else:
self.N = kt.kron_N(self.x)
self.Np = kt.kron_N(self.xp)
self.kernel = kernel
self.mode = mode
self.Sigmay = Sigmay
if prior_mean is None:
self.yp = np.zeros([self.N, 1])
self.fp = np.zeros([self.Np, 1])
else:
self.yp = (prior_mean(x)).reshape(self.N, 1)
self.fp = (prior_mean(xp)).reshape(self.Np, 1)
self.yDat = y.reshape(self.N, 1) - self.yp
if self.mode == "Full" or self.mode == "kron":
self.XX = XX
self.XXp = XXp
elif self.mode == "RR":
self.grid_regular = grid_regular
self.Phi = Phi
self.PhiTPhi = PhiTPhi
self.Phip = Phip
self.s = s
def __init__(self, x, theta, kernels=["sqexp"], precond_mode="Full"):
self.D = x.shape[0]
self.N = kt.kron_N(x)
self.x = x
# get individual shapes
self.Ds = np.zeros(self.D, dtype=np.int8)
self.precond_mode = precond_mode
thetan = np.zeros([self.D, 3])
thetan[:, 0] = theta[0]
thetan[:, -1] = theta[-1]
for i in xrange(
self.D
): # this is how many length scales will be involved in te problem
self.Ds[i] = self.x[i].shape[0]
thetan[i, 1] = theta[
i +
1] # assuming we set up the theta vector as [[sigmaf, l_1, sigman], [sigmaf, l_2, ..., sigman]]
self.theta = theta
self.eps = self.theta[-1]**2 # default nugget
# set up kernels for each dimension
self.kernels = []
self.Phis = np.empty(self.D, dtype=object)
self.Lambdas = np.empty(self.D, dtype=object)
for i, k in enumerate(kernels):
if k == "sqexp":
self.kernels.append(
expsq.sqexp_op(
x[i],
thetan[i],
np.prod(np.delete(self.Ds, i)),
wisdom_file=
'/home/landman/Projects/GP/fft_wisdom/test.wisdom.npy',
reset_wisdom=True))
if self.precond_mode == "Full":
self.kernels[i].set_eigs(
) # default nugget, reset if it changes
self.Phis[i] = self.kernels[i].Q
self.Lambdas[i] = self.kernels[i].Lambda_full
elif self.precond_mode == "RR":
self.kernels[i].set_RR_eigs(nugget=theta[-1]**2)
self.Phis[i] = self.kernels[i].Phi
self.Lambdas[i] = self.kernels[
i].S # approximate power spectrum
else:
raise Exception("Unsupported precond mode %s" %
self.precond_mode)
else:
raise Exception("Unsupported kernel %s" % k)
self.PhisT = kt.kron_transpose(self.Phis)
self.shape = (self.N, self.N)
self.dtype = np.float64
def test_diagonal_noise(A, K):
N = kt.kron_N(A)
Sigmay = np.ones(N) + np.abs(np.random.randn(N))
Ky = K + np.diag(Sigmay)
Kyinv = np.linalg.inv(Ky)
Sigmayinv = np.diag(1.0 / Sigmay)
Lambdas, Qs = kt.kron_eig(A)
Q = kt.kron_kron(Qs)
Lambda = kt.kron_diag(Lambdas)
Kyinv2 = Sigmayinv - Sigmayinv.dot(
Q.dot(
np.linalg.inv(np.diag(1.0 / Lambda) +
Q.T.dot(Sigmayinv.dot(Q))).dot(Q.T.dot(Sigmayinv))))
compare(Kyinv, Kyinv2, 'diagonal noise')
def __init__(self,
x,
y,
kernel,
Sigmay=None,
mode="Full",
prior_mean=None,
XX=None,
Phi=None,
PhiTPhi=None,
s=None,
grid_regular=False):
"""
:param x: inputs
:param y: Nx1 vector of data
:param kernel: a class holding the covariance function and spectral densities
:param mode: whether to use full or RR GPR
:param XX: absolute differences of inputs
:param Phi: basis functions evaluated at x
:param PhiTPhi: the product dot(Phi.T, Phi)
:param s: square root of eigenvalues
:param grid_regular: whether x is on a regular grid or not
"""
self.x = x
self.kernel = kernel
self.mode = mode
if self.mode != "kron":
self.N = self.x.shape[0]
else:
self.N = kt.kron_N(self.x)
self.Sigmay = Sigmay
if prior_mean is None:
yp = np.zeros([self.N, 1])
else:
yp = prior_mean(x).reshape(self.N, 1)
self.yDat = y.reshape(self.N, 1) - yp
if self.mode == "Full" or self.mode == "kron":
self.XX = XX
elif self.mode == "RR":
self.yTy = np.dot(self.yDat.T, self.yDat)
self.s = s
self.M = PhiTPhi.shape[0]
self.Phi = Phi
self.grid_regular = grid_regular
self.PhiTPhi = PhiTPhi
else:
raise Exception('Mode %s not supported yet' % self.mode)