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)