def __init__(self,
input_dim,
numc,
lengthscales=None,
variances=None,
frequencies=None):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
self.ARD = False
self.numc = numc
if lengthscales == None:
lengthscales = 1.
variances = 0.125 * np.ones((numc, 1))
frequencies = 1. * np.arange(1, numc + 1)
self.lengthscales = Param(lengthscales, transforms.Logistic(0., 10.))
for i in range(
self.numc
): # generate a param object for each var, and freq, they must be (numc,) arrays.
setattr(self, 'variance_' + str(i + 1),
Param(variances[i], transforms.Logistic(0., 0.25)))
setattr(self, 'frequency_' + str(i + 1),
Param(frequencies[i], transforms.positive))
for i in range(self.numc):
exec('self.variance_' + str(i + 1) + '.fixed = ' + str(True))
def __init__(self, X, Y, kern, likelihood, mu_old, Su_old, Kaa_old, Z_old, Z, mean_function=Zero(),
num_latent=None, q_diag=False, whiten=True, minibatch_size=None):
# sort out the X, Y into MiniBatch objects.
if minibatch_size is None:
minibatch_size = X.shape[0]
self.num_data = X.shape[0]
X = MinibatchData(X, minibatch_size, np.random.RandomState(0))
Y = MinibatchData(Y, minibatch_size, np.random.RandomState(0))
# init the super class, accept args
GPModel.__init__(self, X, Y, kern, likelihood, mean_function)
self.q_diag, self.whiten = q_diag, whiten
self.Z = Param(Z)
self.num_latent = num_latent or Y.shape[1]
self.num_inducing = Z.shape[0]
# init variational parameters
self.q_mu = Param(np.zeros((self.num_inducing, self.num_latent)))
if self.q_diag:
self.q_sqrt = Param(np.ones((self.num_inducing, self.num_latent)),
transforms.positive)
else:
q_sqrt = np.array([np.eye(self.num_inducing)
for _ in range(self.num_latent)]).swapaxes(0, 2)
# , transforms.LowerTriangular(q_sqrt.shape[2])) # Temp remove transform
self.q_sqrt = Param(q_sqrt)
self.mu_old = DataHolder(mu_old, on_shape_change='pass')
self.M_old = Z_old.shape[0]
self.Su_old = DataHolder(Su_old, on_shape_change='pass')
self.Kaa_old = DataHolder(Kaa_old, on_shape_change='pass')
self.Z_old = DataHolder(Z_old, on_shape_change='pass')
def __init__(self, X, Y, X_prime):
"""
X is a data vector, size N x 1
X_prime is a vector, size M x 1
Y is a data vector, size N x 1
This is a vanilla implementation of a GP with unimodality contraints and HMC sampling
Refer:
https://bayesopt.github.io/papers/2017/9.pdf
"""
X_concat = np.vstack([X, X_prime])
UnimodalGP.__init__(self)
self.X_concat = DataHolder(X_concat)
self.Y = DataHolder(Y)
self.X = DataHolder(X)
self.X_prime = DataHolder(X_prime)
self.num_data = X_concat.shape[0]
self.num_x_points = X.shape[0]
self.num_der_points = X_prime.shape[0]
self.num_latent = Y.shape[1]
self.Vf = Param(np.zeros((self.num_data, self.num_latent)))
self.Vf.prior = Gaussian(0., 1.)
self.Vg = Param(np.zeros((2 * self.num_der_points, self.num_latent)))
self.Vg.prior = Gaussian(0., 1.)
def __init__(self,
input_dim,
num_partials,
lengthscales=None,
variances=None,
frequencies=None):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
len_l = []
var_l = []
freq_l = []
self.ARD = False
self.num_partials = num_partials
if lengthscales.all() == None:
lengthscales = 1. * np.ones((num_partials, 1))
variances = 0.125 * np.ones((num_partials, 1))
frequencies = 1. * (1. + np.arange(num_partials))
for i in range(self.num_partials):
len_l.append(Param(lengthscales[i], transforms.Logistic(0., 2.)))
var_l.append(Param(variances[i], transforms.Logistic(0., 1.)))
freq_l.append(Param(frequencies[i], transforms.positive))
self.lengthscales = ParamList(len_l)
self.variance = ParamList(var_l)
self.frequency = ParamList(freq_l)
def __init__(self, input_dim, a=1.0, b=1.0, active_dims=None):
"""
"""
gpflow.kernels.Kern.__init__(self, input_dim, active_dims)
self.a = Param(a)
self.b = Param(b)
def __init__(self,
input_dim,
energy=np.asarray([1.]),
frequency=np.asarray([2 * np.pi]),
variance=1.0,
features_as_params=False):
"""
- input_dim is the dimension of the input to the kernel
- variance is the (initial) value for the variance parameter(s)
if ARD=True, there is one variance per input
- active_dims is a list of length input_dim which controls
which columns of X are used.
"""
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
self.num_features = len(frequency)
self.variance = Param(variance, transforms.Logistic(0., 0.25))
if features_as_params:
energy_list = []
frequency_list = []
for i in range(energy.size):
energy_list.append(Param(energy[i], transforms.positive))
frequency_list.append(Param(frequency[i], transforms.positive))
self.energy = ParamList(energy_list)
self.frequency = ParamList(frequency_list)
else:
self.energy = energy
self.frequency = frequency
def __init__(self,
input_dim,
variance=1.,
lengthscales=None,
energy=None,
frequencies=None,
len_fixed=True):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
energy_l = []
freq_l = []
self.ARD = False
self.num_partials = len(energy)
for i in range(self.num_partials):
energy_l.append(Param(energy[i], transforms.positive))
freq_l.append(Param(frequencies[i], transforms.positive))
self.energy = ParamList(energy_l)
self.frequency = ParamList(freq_l)
self.variance = Param(variance, transforms.positive)
self.lengthscales = Param(lengthscales, transforms.positive)
self.vars_n_freqs_fixed(fix_energy=True, fix_freq=True)
if len_fixed:
self.lengthscales.fixed = True
def __init__(self, input_dim, energy=np.asarray([1.]), frequency=np.asarray([2*np.pi]), variance=1.,
lengthscales=1., len_fixed=False):
gpflow.kernels.Stationary.__init__(self, input_dim, variance=variance, lengthscales=lengthscales,
active_dims=None, ARD=False)
# self.variance = Param(variance, transforms.positive())
# self.lengthscale = Param(lengthscale, transforms.positive())
self.num_partials = len(frequency)
energy_list = []
frequency_list = []
for i in range(self.num_partials):
energy_list.append(Param(energy[i], transforms.positive))
frequency_list.append(Param(frequency[i], transforms.positive))
self.energy = ParamList(energy_list)
self.frequency = ParamList(frequency_list)
# self.energy.fixed = True
# self.frequency.fixed = True
# self.energy = energy
# self.frequency = frequency
if len_fixed:
self.lengthscales.fixed = True
def navigate_from(self, Pnew, n, r=0.1):
self.r2 = r * r
self.P_path = np.array([Pnew]).reshape([-1, 2])
Pnew = Pnew.reshape([1, 2])
self.Pnew = Param(np.tile(Pnew, (n, 1)))
self.Pinit = Param(np.array(Pnew))
self.Pinit.fixed = True
self.n = n
def __init__(self, mu=None, lengthscale=None, signal_variance=None):
mu = np.zeros(1) if mu is None else mu
lengthscale = 0.2 * np.ones(1) if lengthscale is None else lengthscale
signal_variance = 3 * np.ones(
1) if signal_variance is None else signal_variance
MeanFunction.__init__(self)
self.signal_variance = Param(signal_variance, transforms.positive)
self.lengthscale = Param(lengthscale, transforms.positive)
self.mu = Param(mu)
def __init__(self,
Y,
latent_dim,
X_mean=None,
kern=None,
mean_function=Zero()):
"""
Initialise GPLVM object. This method only works with a Gaussian likelihood.
:param Y: data matrix, size N (number of points) x D (dimensions)
:param Z: matrix of inducing points, size M (inducing points) x Q (latent dimensions)
:param X_mean: latent positions (N x Q), for the initialisation of the latent space.
:param kern: kernel specification, by default RBF
:param mean_function: mean function, by default None.
"""
if kern is None:
kern = kernels.RBF(latent_dim, ARD=True)
if X_mean is None:
X_mean = PCA_initialization(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,
X,
Y,
kern,
mu_old,
Su_old,
Kaa_old,
Z_old,
Z,
mean_function=Zero()):
"""
X is a data matrix, size N x D
Y is a data matrix, size N x R
Z is a matrix of pseudo inputs, size M x D
kern, mean_function are appropriate gpflow objects
mu_old, Su_old are mean and covariance of old q(u)
Z_old is the old inducing inputs
This method only works with a Gaussian likelihood.
"""
X = DataHolder(X, on_shape_change='pass')
Y = DataHolder(Y, on_shape_change='pass')
likelihood = likelihoods.Gaussian()
GPModel.__init__(self, X, Y, kern, likelihood, mean_function)
self.Z = Param(Z)
self.num_data = X.shape[0]
self.num_latent = Y.shape[1]
self.mu_old = DataHolder(mu_old, on_shape_change='pass')
self.M_old = Z_old.shape[0]
self.Su_old = DataHolder(Su_old, on_shape_change='pass')
self.Kaa_old = DataHolder(Kaa_old, on_shape_change='pass')
self.Z_old = DataHolder(Z_old, on_shape_change='pass')
def navigate(self, delta=0.1):
def _find_neighbors(P, n=8):
embeds = self.X_mean.value
dist = np.sum(np.square(P - embeds), axis=-1)
dist = np.sqrt(dist)
idx = np.argsort(dist)
nei = embeds[idx[:n + 1], :]
return nei, dist[idx[:n + 1]]
n = 8
Pnew = self.Pnew.value
X, dist = _find_neighbors(Pnew, n)
print('\t dist', dist)
A = 0.04
B = 2
dist = dist.reshape([-1, 1])
F = A / (np.power(dist, 1.2)) - B / np.power(dist, 0.2)
F = np.minimum(F, 0.1)
pdir = Pnew - X
pdir = pdir / dist
t = delta
xx = 0.5 * t * t * F
xx = np.sum(pdir * xx, axis=0)
p, W = pca(X, n=1)
W = W.reshape([2])
W = W / np.sqrt(np.sum(W * W))
if len(self.P_path) > 1 and W.dot(self.P_path[-1, :] -
self.P_path[-2, :]) < 0:
W = -1 * W
Pnew = self.Pnew.value + W * delta + xx
self.Pnew = Param(Pnew)
self.P_path = np.append(self.P_path, Pnew, axis=0)
return Pnew, W * 0.1, xx
def __init__(self):
"""
Likelihood for Gaussian Process with unimodality constraints
"""
Likelihood.__init__(self)
self.nuf = 1. / 1e-6
self.nug = 1. / 1e-6
self.noise_variance = Param(1.0, transforms.positive)
def __init__(self, X_variational_mean, X_variational_var, t):
"""
:param X_variational_mean: initial latent variational distribution mean, size N (number of points) x Q (latent dimensions)
:param X_variational_var: initial latent variational distribution std (N x Q)
:param t: time stamps for the variational prior kernel, need to ba an np.narray.
"""
super(GPTimeSeries, self).__init__(name='GPTimeSeries')
self.X_variational_mean = Param(X_variational_mean)
self.X_variational_var = Param(X_variational_var, transforms.positive)
assert X_variational_var.ndim == 2, "the dimensionality of variational prior covariance needs to be 2."
assert np.all(X_variational_mean.shape == X_variational_var.shape), "the shape of variational prior mean and variational prior covariance needs to be equal."
self.num_latent = X_variational_mean.shape[1]
self.num_data = X_variational_mean.shape[0]
assert (isinstance(t, np.ndarray)), "time stamps need to be a numpy array."
t = DataHolder(t)
self.t = t
def __init__(self, input_dim, frequency=None, energy=None, variance=1.0):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
self.ARD = False
self.num_partials = len(frequency)
self.energy = energy
self.variance = Param(variance, transforms.positive)
self.frequency = frequency
def locate_skeletons(self, new_ske):
embeds = self.X_mean.value
skeletons = self.skeletons
new_ske = new_ske.reshape([-1, self.nkpts, 3])
def cal_distSkeletons(shapesA, shapesB):
dist = np.sqrt(((shapesB - shapesA)**2).sum(axis=-1))
dist = dist.sum(axis=-1)
return dist
dist = cal_distSkeletons(new_ske, skeletons)
dist = dist.reshape([-1])
idx = np.argsort(dist)
pStart = embeds[idx[0], :]
pStart = pStart.reshape([1, 2])
self.Xnew = Param(pStart)
self.new_ske = Param(new_ske)
self.new_ske.fixed = True
def __init__(self, actions_list, kerns_list, X_grid):
"""
Collaboartive preference learning through occupants' actions/behavior
Uses information : feature value before action and after action
Inputs:
actions_list : all actions data list (list of actions taken by each occupant) N_i X (2M) where,
N_i : total number of actions taken by occupant i
first half of 2M columns : feature values before action
second half of 2M columns : feature values after action
L : length of the list = total number of occupants
kerns_list : kernels associated with all of the latent GPs
"""
# feature grid points
self.X_grid = X_grid
self.num_x_grid = self.X_grid.shape[0]
# num of latent GPs
self.num_latent_gps = len(kerns_list)
# num of occupants
self.num_occupants = len(actions_list)
# generating indexes for actions : concerned matrix indices
# U is calculated at all of the X_grid points
# When it comes to actions taken by each occupant, we need to find the index associated with each actions
# actions list is the input list, each element of which is the numpy matrix representing feature value before action and after action
prev_ind_list, cur_ind_list = all_occ_prev_cur_act_ind(
actions_list, X_grid)
GPCollabPrefLearn.__init__(self, prev_ind_list, cur_ind_list, X_grid,
kerns_list)
# Prior for H (latent GP matrix) setup
# HMC sampling setup (standard normal distribution : whitening variables)
self.V_h = Param(np.zeros((self.num_latent_gps, self.num_x_grid)))
self.V_h.prior = Gaussian(0., 1.)
self.W = Param(np.random.randn(self.num_occupants,
self.num_latent_gps))
def __init__(self, input_dim, xkern, fkern, variance=1.0, plen=1.0, pvar=1.0):
gpflow.kernels.Stationary.__init__(self, input_dim=input_dim, active_dims=None, ARD=False)
eyem = tf.eye(xkern.size, dtype=float_type)
self.variance = Param(variance, transforms.positive)
self.plen = plen
self.pvar = pvar
self.fkern = fkern
self.xkern = xkern
self.kern = gpflow.kernels.RBF(input_dim=input_dim, variance=self.pvar, lengthscales=self.plen)
self.cov = tf.matmul(eyem, self.kern.compute_K_symm(xkern))
self.icov = tf.matrix_inverse(self.cov + jitter*eyem)
def compile(self, session=None, graph=None, optimizer=None):
"""
Before calling the standard compile function, check to see if the size
of the data has changed and add parameters appropriately.
This is necessary because the shape of the parameters depends on the
shape of the data.
"""
if not self.num_data == self.X_concat.shape[0]:
#print "wink wink"
self.num_data = self.X_concat.shape[0]
self.num_x_points = self.X.shape[0]
self.num_der_points = self.X_prime.shape[0]
self.Vf = Param(np.zeros((self.num_data, self.num_latent)))
self.Vf.prior = Gaussian(0., 1.)
self.Vg = Param(
np.zeros((2 * self.num_der_points, self.num_latent)))
self.Vg.prior = Gaussian(0., 1.)
return super(UnimodalGPMC, self).compile(session=session,
graph=graph,
optimizer=optimizer)
def __init__(self, embeds, m, name='Model'):
Model.__init__(self, name)
self.nkpts = len(m.Y.value[0])
self.npts = len(embeds)
embeds = np.array(m.X_mean.value)
self.X_mean = Param(embeds)
self.Z = Param(np.array(m.Z.value))
self.kern = deepcopy(m.kern)
self.X_var = Param(np.array(m.X_var.value))
self.Y = m.Y
self.likelihood = likelihoods.Gaussian()
self.mean_function = Zero()
self.likelihood._check_targets(self.Y.value)
self._session = None
self.X_mean.fixed = True
self.Z.fixed = True
self.kern.fixed = True
self.X_var.fixed = True
self.likelihood.fixed = True
def local_pca(self, delta=0.1):
def _find_neighbors(P, n=8):
embeds = self.X_mean.value
dist = np.sum(np.square(P - embeds), axis=-1)
idx = np.argsort(dist)[::-1]
nei = embeds[idx[:n + 1], :]
return nei
X = _find_neighbors(self.Pnew.value, 8)
p, W = pca(X)
W = W / np.sqrt(np.sum(W * W))
Pnew = self.Pnew.value + W * delta
self.Pnew = Param(Pnew)
return Pnew
def __init__(self, embeds, skeletons, dist, m, name='Model'):
Model.__init__(self, name)
self.skeletons = skeletons
self.dist_embeds = dist
self.nkpts = len(skeletons[0, :])
self.npts = len(embeds)
self.dist_skeletons = np.ones([self.npts, self.npts]) * -1
embeds = np.array(m.X_mean.value)
self.X_mean = Param(embeds)
self.Z = Param(np.array(m.Z.value))
self.kern = deepcopy(m.kern)
self.X_var = Param(np.array(m.X_var.value))
self.Y = m.Y
self.likelihood = likelihoods.Gaussian()
self.mean_function = Zero()
self.likelihood._check_targets(self.Y.value)
self._session = None
self.X_mean.fixed = True
self.Z.fixed = True
self.kern.fixed = True
self.X_var.fixed = True
self.likelihood.fixed = True
def __init__(self, X, Y, kern, Z, alpha, mean_function=Zero()):
"""
X is a data matrix, size N x D
Y is a data matrix, size N x R
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.
"""
X = DataHolder(X, on_shape_change='pass')
Y = DataHolder(Y, on_shape_change='pass')
likelihood = likelihoods.Gaussian()
GPModel.__init__(self, X, Y, kern, likelihood, mean_function)
self.Z = Param(Z)
self.num_data = X.shape[0]
self.num_latent = Y.shape[1]
self.alpha = alpha
def __init__(self, X_variational_mean, X_variational_var, Y, kern, t, kern_t, M , Z=None):
"""
Initialization of Bayesian Gaussian Process Dynamics Model. This method only works with Gaussian likelihood.
:param X_variational_mean: initial latent positions, size N (number of points) x Q (latent dimensions).
:param X_variational_var: variance of latent positions (N x Q), for the initialisation of the latent space.
:param Y: data matrix, size N (number of points) x D (dimensions).
:param kern: kernel specification, by default RBF.
:param t: time stamps.
:param kern_t: dynamics kernel specification, by default RBF.
:param M: number of inducing points.
:param Z: matrix of inducing points, size M (inducing points) x Q (latent dimensions), By default
random permutation of X_mean.
"""
super(BayesianDGPLVM, self).__init__(name='BayesianDGPLVM')
self.kern = kern
assert len(X_variational_mean) == len(X_variational_var), 'must be same amount of time series'
self.likelihood = likelihoods.Gaussian()
# multiple sequences
series = []
for i in range(len(X_variational_mean)):
series.append(GPTimeSeries(X_variational_mean[i], X_variational_var[i], t[i]))
self.series = ParamList(series)
# inducing points
if Z is None:
# By default we initialize by permutation of initial
Z = np.random.permutation(np.concatenate(X_variational_mean, axis=0).copy())[:M]
else:
assert Z.shape[0] == M
self.Z = Param(Z)
self.kern_t = kern_t
self.Y = DataHolder(Y)
self.M = M
self.n_s = 0
def __init__(self, input_dim, variance=1., frequency=1.):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
self.variance = Param(variance, transforms.positive)
self.frequency = Param(frequency, transforms.positive)
def __init__(self,
X,
Y,
kernf,
kerng,
likelihood,
Zf,
Zg,
mean_function=None,
minibatch_size=None,
name='model'):
Model.__init__(self, name)
self.mean_function = mean_function or Zero()
self.kernf = kernf
self.kerng = kerng
self.likelihood = likelihood
self.whiten = False
self.q_diag = True
# save initial attributes for future plotting purpose
Xtrain = DataHolder(X)
Ytrain = DataHolder(Y)
self.Xtrain, self.Ytrain = Xtrain, Ytrain
# sort out the X, Y into MiniBatch objects.
if minibatch_size is None:
minibatch_size = X.shape[0]
self.num_data = X.shape[0]
self.num_latent = Y.shape[1] # num_latent will be 1
self.X = MinibatchData(X, minibatch_size, np.random.RandomState(0))
self.Y = MinibatchData(Y, minibatch_size, np.random.RandomState(0))
# Add variational paramters
self.Zf = Param(Zf)
self.Zg = Param(Zg)
self.num_inducing_f = Zf.shape[0]
self.num_inducing_g = Zg.shape[0]
# init variational parameters
self.u_fm = Param(
np.random.randn(self.num_inducing_f, self.num_latent) * 0.01)
self.u_gm = Param(
np.random.randn(self.num_inducing_g, self.num_latent) * 0.01)
if self.q_diag:
self.u_fs_sqrt = Param(
np.ones((self.num_inducing_f, self.num_latent)),
transforms.positive)
self.u_gs_sqrt = Param(
np.ones((self.num_inducing_g, self.num_latent)),
transforms.positive)
else:
u_fs_sqrt = np.array([
np.eye(self.num_inducing_f) for _ in range(self.num_latent)
]).swapaxes(0, 2)
self.u_fs_sqrt = Param(
u_fs_sqrt, transforms.LowerTriangular(u_fs_sqrt.shape[2]))
u_gs_sqrt = np.array([
np.eye(self.num_inducing_g) for _ in range(self.num_latent)
]).swapaxes(0, 2)
self.u_gs_sqrt = Param(
u_gs_sqrt, transforms.LowerTriangular(u_gs_sqrt.shape[2]))
def __init__(self,
X_variational_mean,
X_variational_var,
Y,
Kern,
M,
Z=None,
X_prior_mean=None,
X_prior_var=None):
"""
Initialise Bayesian GPLVM object. This method only works with a Gaussian likelihood.
:param X_variational_mean: initial latent variational distribution mean, size N (number of points) x Q (latent dimensions)
:param X_variational_var: initial latent variational distribution std (N X Q)
:param Y: data matrix, size N (number of points) x D (dimensions)
:param Kern: kernal specification, by default RBF-ARD
:param M: number of inducing points
:param Z: matrix of inducing points, size M (inducing points) x Q (latent dimensions). By default
random permutation of X_mean.
:param X_prior_mean: prior mean used in KL term of bound. By default 0. Same size as X_mean.
:param X_prior_var: prior variance used in KL term of bound. By default 1.
"""
GPModel.__init__(self,
X_variational_mean,
Y,
Kern,
likelihood=likelihoods.Gaussian(),
mean_function=Zero())
del self.X # in GPLVM this is a Param
self.X_variational_mean = Param(X_variational_mean)
assert X_variational_var.ndim == 2, 'Incorrect number of dimensions for X_std.'
self.X_variational_var = Param(X_variational_var, transforms.positive)
self.num_data = X_variational_mean.shape[0]
self.output_dim = Y.shape[1]
assert np.all((X_variational_mean.shape == X_variational_var.shape))
assert X_variational_mean.shape[0] == Y.shape[
0], 'X variational mean and Y must be the same size.'
assert X_variational_var.shape[0] == Y.shape[
0], 'X variational std and Y must be the same size.'
# inducing points
if Z is None:
# By default it's initialized by random permutation of the latent inputs.
Z = np.random.permutation(X_variational_mean.copy())[:M]
else:
assert Z.shape[
0] == M, 'Only M inducing points are allowed, however {} are provided.'.format(
Z.shape[0])
self.Z = Param(Z)
self.num_latent = Z.shape[1]
assert X_variational_mean.shape[1] == self.num_latent
# Prior mean and variance for X TODO: the dynamic case is different
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_var.shape[0] == self.num_data
assert X_prior_var.shape[1] == self.num_latent
assert X_prior_mean.shape[0] == self.num_data
assert X_prior_mean.shape[1] == self.num_latent
def __init__(self, input_dim, variance=1., lengthscales=1., gamma=1.):
gpflow.kernels.Stationary.__init__(self,
input_dim=input_dim,
variance=variance,
lengthscales=lengthscales)
self.gamma = Param(gamma, transforms.Logistic(0.00001, 2.))
def __init__(self, input_dim, gpm, variance=1.0):
gpflow.kernels.Kern.__init__(self, input_dim, active_dims=None)
self.variance = Param(variance, transforms.positive)
self.m = gpm
self.m.fixed = True
