def __init__(self,
X,
Y,
kern,
likelihood,
Z,
colour_channels,
mean_function=GPflow.mean_functions.Zero(),
num_latent=None,
q_diag=False,
whiten=True,
minibatch_size=None):
assert not q_diag
super(SVColourConvGP,
self).__init__(X, Y, kern, likelihood, Z, mean_function,
num_latent, q_diag, whiten, minibatch_size)
# init variational parameters
self.q_mu = Param(
np.zeros((self.num_inducing, self.num_latent * colour_channels)))
q_sqrt = np.array([
np.eye(self.num_inducing)
for _ in range(self.num_latent * colour_channels)
]).swapaxes(0, 2).reshape(self.num_inducing, self.num_inducing,
self.num_latent * colour_channels)
self.q_sqrt = Param(
q_sqrt
) # , transforms.LowerTriangular(q_sqrt.shape[2])) # Temp remove transform
self.colour_channels = colour_channels
self.wc = GPflow.param.Param(np.ones(colour_channels))
def __init__(self,
X_mean,
X_var,
Y,
kern,
M,
Z=None,
X_prior_mean=None,
X_prior_var=None):
"""
X_mean is a data matrix, size N x D
X_var is a data matrix, size N x D (X_var > 0)
Y is a data matrix, size N x R
M is the number of inducing points
Z is a matrix of pseudo inputs, size M x D
kern, mean_function are appropriate GPflow objects
This method only works with a Gaussian likelihood.
"""
GPModel.__init__(self,
X_mean,
Y,
kern,
likelihood=likelihoods.Gaussian(),
mean_function=Zero())
del self.X
self.X_mean = Param(X_mean)
self.X_var = Param(X_var, transforms.positive)
self.num_data = X_mean.shape[0]
self.output_dim = Y.shape[1]
assert np.all(X_mean.shape == X_var.shape)
assert X_mean.shape[0] == Y.shape[0], 'X mean and Y must be same size.'
assert X_var.shape[0] == Y.shape[0], 'X var and Y must be same size.'
# inducing points
if Z is None:
# By default we initialize by subset of initial latent points
Z = np.random.permutation(X_mean.copy())[:M]
else:
assert Z.shape[0] == M
self.Z = Param(Z)
self.num_latent = Z.shape[1]
assert X_mean.shape[1] == self.num_latent
# deal with parameters for the prior mean variance of X
if X_prior_mean is None:
X_prior_mean = np.zeros((self.num_data, self.num_latent))
self.X_prior_mean = X_prior_mean
if X_prior_var is None:
X_prior_var = np.ones((self.num_data, self.num_latent))
self.X_prior_var = X_prior_var
assert X_prior_mean.shape[0] == self.num_data
assert X_prior_mean.shape[1] == self.num_latent
assert X_prior_var.shape[0] == self.num_data
assert X_prior_var.shape[1] == self.num_latent
def __init__(self, denseAdjMat, denseFeatureMat, X_tr, degree=3.0, variance=1.0, offset=1.0):
GPflow.kernels.Kern.__init__(self, 1)
self.degree = degree
self.offset = Param(offset, transform=transforms.positive)
self.variance = Param(variance, transforms.positive)
denseAdjMat[np.diag_indices(len(denseAdjMat))] = 1.
self.tr_features, self.tr_masks, self.tr_masks_counts = self._diag_tr_helper(denseFeatureMat, denseAdjMat, X_tr)
self.sparse_P = SparseDataHolder(sparse_to_tuple(sparse.csr_matrix(
denseAdjMat/np.sum(denseAdjMat, 1, keepdims=True))))
self.sparseFeatureMat = SparseDataHolder(sparse_to_tuple(sparse.csr_matrix(denseFeatureMat)))
self.denseFeatureMat = DataHolder(denseFeatureMat)
def __init__(self, input_dim, **kwargs):
gpf.kernels.Kern.__init__(self, 2 * input_dim, **kwargs)
self.latent_input_dim = input_dim
if not 'lengthscales' in kwargs.keys():
lengthscales = np.ones(input_dim, np_float_type)
else:
# accepts float or array:
lengthscales = kwargs['lengthscales'] * np.ones(
input_dim, np_float_type)
self.lengthscales = Param(lengthscales, transforms.positive)
if not 'variance' in kwargs.keys():
variance = 1.
self.variance = Param(variance, transforms.positive)
def __init__(self,
Y,
latent_dim,
X_mean=None,
kern=None,
mean_function=Zero()):
"""
Y is a data matrix, size N x R
Z is a matrix of pseudo inputs, size M x D
X_mean is a matrix, size N x Q, for the initialisation of the latent space.
kern, mean_function are appropriate GPflow objects
This method only works with a Gaussian likelihood.
"""
if kern is None:
kern = kernels.RBF(latent_dim, ARD=True)
if X_mean is None:
X_mean = PCA_reduce(Y, latent_dim)
assert X_mean.shape[
1] == latent_dim, 'Passed in number of latent ' + str(
latent_dim) + ' does not match initial X ' + str(
X_mean.shape[1])
self.num_latent = X_mean.shape[1]
assert Y.shape[
1] >= self.num_latent, 'More latent dimensions than observed.'
GPR.__init__(self, X_mean, Y, kern, mean_function=mean_function)
del self.X # in GPLVM this is a Param
self.X = Param(X_mean)
def __init__(self,
Y,
latent_dim,
X_mean=None,
kern=None,
back_kern=None,
mean_function=Zero()):
"""
Initialise GPLVM object. This method only works with a Gaussian likelihood.
:param Y: data matrix (N x D)
:param X_mean: latent positions (N x Q), by default initialized using PCA.
:param kern: kernel specification, by default RBF
:param mean_function: mean function, by default None.
"""
# define kernel function
if kern is None:
kern = kernels.RBF(latent_dim)
back_kern = kernels.RBF(latent_dim)
# initialize latent_positions
if X_mean is None:
X_mean = PCA_reduce(Y, latent_dim)
# initialize variables
self.num_latent = X_mean.shape[1]
# initialize variables
likelihood = likelihoods.Gaussian()
Y = DataHolder(Y, on_shape_change='pass')
X = DataHolder(X_mean, on_shape_change='pass')
# initialize parent GPModel
GPModel.__init__(self, X, Y, kern, likelihood, mean_function)
# initialize back constraint model
self.back_kern = back_kern
self.back_mean_function = Zero()
self.back_likelihood = likelihoods.Gaussian()
# set latent positions as model param
del self.X
self.X = Param(X_mean)
def __init__(self, kern, q_mu, q_sqrt, Z, mean_function):
Parameterized.__init__(self)
self.q_mu, self.q_sqrt, self.Z = Param(q_mu), Param(q_sqrt), Param(Z)
self.kern = kern
self.mean_function = mean_function
def __init__(self, output_dim, c=None):
MeanFunction.__init__(self, output_dim)
if c is None:
c = np.ones(output_dim, np_float_type)
self.c = Param(c)