def __init__(self,
X,
Y,
kern,
mu_old,
Su_old,
Kaa_old,
Z_old,
Z,
likelihood=likelihoods.Gaussian(),
mean_function=None):
"""
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 = X
# Y=Y
self.X = Param('input', X)
self.Y = Param('output', Y)
# likelihood = likelihoods.Gaussian()
# GPModel.__init__(self, X, Y, kern, likelihood, mean_function)
GP.__init__(self,
X,
Y,
kern,
likelihood,
mean_function,
inference_method=None)
# GP.__init__(self, X, Y, kern, likelihood, mean_function)
# SparseGP.__init__(self, X, Y, Z, kern, likelihood, mean_function, inference_method = GPy.inference.latent_function_inference.VarDTC())
# SparseGP.__init__(self, X, Y, Z, kern, likelihood, mean_function, inference_method = None)
self.Z = Param('inducing inputs', Z)
self.link_parameter(self.Z)
self.mean_function = mean_function
self.num_data = X.shape[0]
self.num_latent = Y.shape[1]
self.mu_old = mu_old
self.M_old = Z_old.shape[0]
self.Su_old = Su_old
self.Kaa_old = Kaa_old
self.Z_old = Z_old
self.ARD = True
self.grad_fun = grad(self.objective)
def __init__(self, input_dim,
variance1=1., variance2=1., lengthscale1=1., lengthscale2=1., xc=1,
active_dims=None):
super(ChangepointRBF, self).__init__(input_dim, active_dims, 'chngpt')
assert input_dim == 1, "For this kernel we assume input_dim = 1"
self.variance1 = Param('variance1', variance1)
self.variance2 = Param('variance2', variance2)
self.lengthscale1 = Param('lengthscale1', lengthscale1)
self.lengthscale2 = Param('lengthscale2', lengthscale2)
self.rbf = RBF(input_dim=input_dim, lengthscale=1., variance=1.)
self.xc = Param('xc', xc)
self.add_parameters(self.variance1, self.variance2, self.lengthscale1, self.lengthscale2, self.xc)
def __init__(self, which, X, X_variance, Z, num_inducing, kernel):
super(PsiStatModel, self).__init__(name='psi stat test')
self.which = which
self.X = Param("X", X)
self.X_variance = Param('X_variance', X_variance, Logexp())
self.q = NormalPosterior(self.X, self.X_variance)
self.Z = Param("Z", Z)
self.N, self.input_dim = X.shape
self.num_inducing, input_dim = Z.shape
assert self.input_dim == input_dim, "shape missmatch: Z:{!s} X:{!s}".format(
Z.shape, X.shape)
self.kern = kernel
self.psi_ = self.kern.__getattribute__(self.which)(self.Z, self.q)
self.add_parameters(self.q, self.Z, self.kern)
def __init__(self, param1=2., param2=3.):
super(TestLikelihood, self).__init__("TestLike")
self.p1 = Param('param1', param1)
self.p2 = Param('param2', param2)
self.link_parameter(self.p1)
self.link_parameter(self.p2)
self.p1.fix()
self.p1.unfix()
self.p2.constrain_negative()
self.p1.fix()
self.p2.constrain_positive()
self.p2.fix()
self.p2.constrain_positive()
def __init__(self, X, Y, kernel=None, sigma2=1.0, name='StateSpace'):
super(StateSpace, self).__init__(name=name)
self.num_data, input_dim = X.shape
assert input_dim == 1, "State space methods for time only"
num_data_Y, self.output_dim = Y.shape
assert num_data_Y == self.num_data, "X and Y data don't match"
assert self.output_dim == 1, "State space methods for single outputs only"
# Make sure the observations are ordered in time
sort_index = np.argsort(X[:, 0])
self.X = X[sort_index]
self.Y = Y[sort_index]
# Noise variance
self.sigma2 = Param('Gaussian_noise', sigma2)
self.link_parameter(self.sigma2)
# Default kernel
if kernel is None:
self.kern = kern.Matern32(1)
else:
self.kern = kernel
self.link_parameter(self.kern)
self.sigma2.constrain_positive()
# Assert that the kernel is supported
if not hasattr(self.kern, 'sde'):
raise NotImplementedError(
'SDE must be implemented for the kernel being used')
def setUp(self):
self.rbf = GPy.kern.RBF(20)
self.white = GPy.kern.White(1)
from GPy.core.parameterization import Param
from GPy.core.parameterization.transformations import Logistic
self.param = Param('param', np.random.uniform(0, 1, (10, 5)),
Logistic(0, 1))
self.test1 = GPy.core.Parameterized("test model")
self.test1.param = self.param
self.test1.kern = self.rbf + self.white
self.test1.link_parameter(self.test1.kern)
self.test1.link_parameter(self.param, 0)
# print self.test1:
#=============================================================================
# test_model. | Value | Constraint | Prior | Tied to
# param | (25L, 2L) | {0.0,1.0} | |
# add.rbf.variance | 1.0 | 0.0,1.0 +ve | |
# add.rbf.lengthscale | 1.0 | 0.0,1.0 +ve | |
# add.white.variance | 1.0 | 0.0,1.0 +ve | |
#=============================================================================
x = np.linspace(-2, 6, 4)[:, None]
y = np.sin(x)
self.testmodel = GPy.models.GPRegression(x, y)
def test_add_parameter_in_hierarchy(self):
self.test1.kern.rbf.link_parameter(
Param("NEW", np.random.rand(2), NegativeLogexp()), 1)
self.assertListEqual(
self.test1.constraints[NegativeLogexp()].tolist(),
range(self.param.size + 1, self.param.size + 1 + 2))
self.assertListEqual(
self.test1.constraints[GPy.transformations.Logistic(0,
1)].tolist(),
range(self.param.size))
self.assertListEqual(
self.test1.constraints[GPy.transformations.Logexp(0, 1)].tolist(),
np.r_[50, 53:55].tolist())
def test_param(self):
param = Param('test', np.arange(4 * 2).reshape(4, 2))
param[0].constrain_positive()
param[1].fix()
param[2].set_prior(Gaussian(0, 1))
pcopy = param.copy()
self.assertListEqual(param.tolist(), pcopy.tolist())
self.assertListEqual(str(param).split('\n'), str(pcopy).split('\n'))
self.assertIsNot(param, pcopy)
with tempfile.TemporaryFile('w+b') as f:
pickle.dump(param, f)
f.seek(0)
pcopy = pickle.load(f)
self.assertListEqual(param.tolist(), pcopy.tolist())
self.assertSequenceEqual(str(param), str(pcopy))
def __init__(self,
X,
Y,
Z,
kern_list,
likelihood,
mean_functions=None,
name='SVGPMulti',
Y_metadata=None,
batchsize=None):
"""
Extension to the SVGP to allow multiple latent function,
where the latent functions are assumed independant (have one kernel per latent function)
"""
# super(SVGPMulti, self).__init__(name) # Parameterized.__init__(self)
assert X.ndim == 2
self.Y_metadata = Y_metadata
_, self.output_dim = Y.shape
# self.Z = Param('inducing inputs', Z)
# self.num_inducing = Z.shape[0]
# self.likelihood = likelihood
self.kern_list = kern_list
self.batchsize = batchsize
#Batch the data
self.X_all, self.Y_all = X, Y
if batchsize is None:
X_batch, Y_batch = X, Y
else:
import climin.util
#Make a climin slicer to make drawing minibatches much quicker
self.slicer = climin.util.draw_mini_slices(self.X_all.shape[0],
self.batchsize)
X_batch, Y_batch = self.new_batch()
# if isinstance(X_batch, (ObsAr, VariationalPosterior)):
# self.X = X_batch.copy()
# else:
# self.X = ObsAr(X_batch)
# self.Y = Y_batch
#create the SVI inference method
# self.inference_method = svgp_inf()
inference_method = svgp_inf()
#Initialize base model
super(SVGPMulti, self).__init__(X=X_batch,
Y=Y_batch,
Z=Z,
kernel=kern_list[0],
likelihood=likelihood,
mean_function=None,
X_variance=None,
inference_method=inference_method,
name=name,
Y_metadata=Y_metadata,
normalizer=False)
self.unlink_parameter(self.kern) # We don't want a single kern
# self.num_data, self.input_dim = self.X.shape
self.num_outputs = self.Y.shape[1]
self.num_latent_funcs = self.likelihood.request_num_latent_functions(
self.Y_all)
#Make a latent function per dimension
self.q_u_means = Param(
'q_u_means', np.zeros((self.num_inducing, self.num_latent_funcs)))
chols = choleskies.triang_to_flat(
np.tile(
np.eye(self.num_inducing)[None, :, :],
(self.num_latent_funcs, 1, 1)))
self.q_u_chols = Param('qf_u_chols', chols)
self.link_parameter(self.Z, index=0)
self.link_parameter(self.q_u_means)
self.link_parameter(self.q_u_chols)
# self.link_parameter(self.likelihood)
#Must pass a list of kernels that work on each latent function for now
assert len(kern_list) == self.num_latent_funcs
#Add the rest of the kernels, one kernel per latent function
[self.link_parameter(kern) for kern in kern_list]
#self.latent_f_list = [self.mf, self.mg]
#self.latent_fchol_list = [self.cholf, self.cholg]
if mean_functions is None:
self.mean_functions = [None] * self.num_latent_funcs
elif len(mean_functions) != len(kern_list):
raise ValueError("Must provide a mean function for all latent\n\
functions as a list, provide None if no latent\n\
function is needed for a specific latent function"
)
else:
self.mean_functions = []
for m_f in mean_functions:
if m_f is not None:
self.link_parameter(m_f)
self.mean_functions.append(m_f)
def __init__(self, kernel=None, dL_dK=None, X=None, X2=None):
super(Kern_check_dK_dX, self).__init__(kernel=kernel,dL_dK=dL_dK, X=X, X2=X2)
self.X = Param('X',X)
self.link_parameter(self.X)
def __init__(self, kernel=None, dL_dK=None, X=None):
super(Kern_check_d2Kdiag_dXdX, self).__init__(kernel=kernel,dL_dK=dL_dK, X=X)
self.X = Param('X',X)
self.link_parameter(self.X)
self.Xc = X.copy()
def __init__(self,
X,
Y,
Z,
kern_list,
likelihood,
Y_metadata,
name='SVMOGP',
batch_size=None):
self.batch_size = batch_size
self.kern_list = kern_list
self.likelihood = likelihood
self.Y_metadata = Y_metadata
self.num_inducing = Z.shape[0] # M
self.num_latent_funcs = len(kern_list) # Q
self.num_output_funcs = likelihood.num_output_functions(
self.Y_metadata)
self.W_list, self.kappa_list = util.random_W_kappas(
self.num_latent_funcs, self.num_output_funcs, rank=1)
self.Xmulti = X
self.Ymulti = Y
# Batch the data
self.Xmulti_all, self.Ymulti_all = X, Y
if batch_size is None:
self.stochastic = False
Xmulti_batch, Ymulti_batch = X, Y
else:
# Makes a climin slicer to make drawing minibatches much quicker
self.stochastic = True
self.slicer_list = []
[
self.slicer_list.append(
draw_mini_slices(Xmulti_task.shape[0], self.batch_size))
for Xmulti_task in self.Xmulti
]
Xmulti_batch, Ymulti_batch = self.new_batch()
self.Xmulti, self.Ymulti = Xmulti_batch, Ymulti_batch
# Initialize inducing points Z
#Z = kmm_init(self.X_all, self.num_inducing)
self.Xdim = Z.shape[1]
Z = np.tile(Z, (1, self.num_latent_funcs))
inference_method = SVMOGPInf()
super(SVMOGP, self).__init__(X=Xmulti_batch[0][1:10],
Y=Ymulti_batch[0][1:10],
Z=Z,
kernel=kern_list[0],
likelihood=likelihood,
mean_function=None,
X_variance=None,
inference_method=inference_method,
Y_metadata=Y_metadata,
name=name,
normalizer=False)
self.unlink_parameter(
self.kern) # Unlink SparseGP default param kernel
_, self.B_list = util.LCM(input_dim=self.Xdim,
output_dim=self.num_output_funcs,
rank=1,
kernels_list=self.kern_list,
W_list=self.W_list,
kappa_list=self.kappa_list)
# Set-up optimization parameters: [Z, m_u, L_u]
self.q_u_means = Param(
'm_u',
5 * np.random.randn(self.num_inducing, self.num_latent_funcs) +
np.tile(np.random.randn(1, self.num_latent_funcs),
(self.num_inducing, 1)))
chols = choleskies.triang_to_flat(
np.tile(
np.eye(self.num_inducing)[None, :, :],
(self.num_latent_funcs, 1, 1)))
self.q_u_chols = Param('L_u', chols)
self.link_parameter(self.Z, index=0)
self.link_parameter(self.q_u_means)
self.link_parameters(self.q_u_chols)
[self.link_parameter(kern_q)
for kern_q in kern_list] # link all kernels
[self.link_parameter(B_q) for B_q in self.B_list]
self.vem_step = True # [True=VE-step, False=VM-step]
self.ve_count = 0
self.elbo = np.zeros((1, 1))
def __init__(self, name=None, parameters=[], *a, **kw):
super(Test, self).__init__(name=name)
self.x = Param('x', np.random.uniform(0, 1, (3, 4)))
self.x[0].constrain_bounded(0, 1)
self.link_parameter(self.x)
self.x[1].fix()
def __init__(self,
X,
Y,
Z,
kern_list,
likelihood,
Y_metadata,
name='HetMOGP',
batch_size=None):
"""
:param X: Input data
:param Y: (Heterogeneous) Output data
:param Z: Inducing inputs
:param kern_list: Kernel functions of GP priors
:param likelihood: (Heterogeneous) Likelihoods
:param Y_metadata: Linking info between F->likelihoods
:param name: Model name
:param batch_size: Size of batch for stochastic optimization
Description: Initialization method for the model class
"""
#---------------------------------------# INITIALIZATIONS #--------------------------------------------#
####### Initialization of class variables #######
self.batch_size = batch_size
self.kern_list = kern_list
self.likelihood = likelihood
self.Y_metadata = Y_metadata
####### Heterogeneous Data #######
self.Xmulti = X
self.Ymulti = Y
####### Batches of Data for Stochastic Mode #######
self.Xmulti_all, self.Ymulti_all = X, Y
if batch_size is None:
self.stochastic = False
Xmulti_batch, Ymulti_batch = X, Y
else:
####### Makes a climin slicer to make drawing minibatches much quicker #######
self.stochastic = True
self.slicer_list = []
[
self.slicer_list.append(
draw_mini_slices(Xmulti_task.shape[0], self.batch_size))
for Xmulti_task in self.Xmulti
]
Xmulti_batch, Ymulti_batch = self.new_batch()
self.Xmulti, self.Ymulti = Xmulti_batch, Ymulti_batch
####### Model dimensions {M, Q, D} #######
self.num_inducing = Z.shape[0] # M
self.num_latent_funcs = len(kern_list) # Q
self.num_output_funcs = likelihood.num_output_functions(
self.Y_metadata)
####### Inducing points Z #######
self.Xdim = Z.shape[1]
Z = np.tile(Z, (1, self.num_latent_funcs))
####### Inference #######
inference_method = Inference()
####### Model class (and inherited classes) super-initialization #######
super(HetMOGP, self).__init__(X=Xmulti_batch[0][1:10],
Y=Ymulti_batch[0][1:10],
Z=Z,
kernel=kern_list[0],
likelihood=likelihood,
mean_function=None,
X_variance=None,
inference_method=inference_method,
Y_metadata=Y_metadata,
name=name,
normalizer=False)
####### Initialization of the Multi-output GP mixing #######
self.W_list, self.kappa_list = multi_output.random_W_kappas(
self.num_latent_funcs, self.num_output_funcs, rank=1)
_, self.B_list = multi_output.LCM(input_dim=self.Xdim,
output_dim=self.num_output_funcs,
rank=1,
kernels_list=self.kern_list,
W_list=self.W_list,
kappa_list=self.kappa_list)
####### Initialization of Variational Parameters (q_u_means = \mu, q_u_chols = lower_triang(S)) #######
self.q_u_means = Param(
'm_u',
0 * np.random.randn(self.num_inducing, self.num_latent_funcs) +
0 * np.tile(np.random.randn(1, self.num_latent_funcs),
(self.num_inducing, 1)))
chols = choleskies.triang_to_flat(
np.tile(
np.eye(self.num_inducing)[None, :, :],
(self.num_latent_funcs, 1, 1)))
self.q_u_chols = Param('L_u', chols)
#-----------------------------# LINKS FOR OPTIMIZABLE PARAMETERS #---------------------------------------#
####### Linking and Un-linking of parameters and hyperaparameters (for ParamZ optimizer) #######
self.unlink_parameter(
self.kern) # Unlink SparseGP default param kernel
self.link_parameter(self.Z, index=0)
self.link_parameter(self.q_u_means)
self.link_parameters(self.q_u_chols)
[self.link_parameter(kern_q)
for kern_q in kern_list] # link all kernels
[self.link_parameter(B_q) for B_q in self.B_list]
####### EXTRA. Auxiliary variables #######
self.vem_step = True # [True=VE-step, False=VM-step]
self.ve_count = 0
self.elbo = np.zeros((1, 1))
def __init__(self,
X,
Y,
Z,
kern_list,
likelihood,
Y_metadata,
name='SVMOGP',
batch_size=None,
non_chained=True):
self.batch_size = batch_size
self.kern_list = kern_list
self.likelihood = likelihood
self.Y_metadata = Y_metadata
self.num_inducing = Z.shape[0] # M
self.num_latent_funcs = len(kern_list) # Q
self.num_output_funcs = likelihood.num_output_functions(Y_metadata)
if (not non_chained):
assert self.num_output_funcs == self.num_latent_funcs, "we need a latent function per likelihood parameter"
if non_chained:
self.W_list, self.kappa_list = util.random_W_kappas(
self.num_latent_funcs, self.num_output_funcs, rank=1)
else:
self.W_list, self.kappa_list = util.Chained_W_kappas(
self.num_latent_funcs, self.num_output_funcs, rank=1)
self.Xmulti = X
self.Ymulti = Y
self.iAnnMulti = Y_metadata['iAnn']
# Batch the data
self.Xmulti_all, self.Ymulti_all, self.iAnn_all = X, Y, Y_metadata[
'iAnn']
if batch_size is None:
#self.stochastic = False
Xmulti_batch, Ymulti_batch, iAnnmulti_batch = X, Y, Y_metadata[
'iAnn']
else:
# Makes a climin slicer to make drawing minibatches much quicker
#self.stochastic = False #"This was True as Pablo had it"
self.slicer_list = []
[
self.slicer_list.append(
draw_mini_slices(Xmulti_task.shape[0], self.batch_size))
for Xmulti_task in self.Xmulti
]
Xmulti_batch, Ymulti_batch, iAnnmulti_batch = self.new_batch()
self.Xmulti, self.Ymulti, self.iAnnMulti = Xmulti_batch, Ymulti_batch, iAnnmulti_batch
self.Y_metadata.update(iAnn=iAnnmulti_batch)
# Initialize inducing points Z
#Z = kmm_init(self.X_all, self.num_inducing)
self.Xdim = Z.shape[1]
Z = np.tile(Z, (1, self.num_latent_funcs))
inference_method = SVMOGPInf()
super(SVMOGP, self).__init__(X=Xmulti_batch[0][1:10],
Y=Ymulti_batch[0][1:10],
Z=Z,
kernel=kern_list[0],
likelihood=likelihood,
mean_function=None,
X_variance=None,
inference_method=inference_method,
Y_metadata=Y_metadata,
name=name,
normalizer=False)
self.unlink_parameter(
self.kern) # Unlink SparseGP default param kernel
_, self.B_list = util.LCM(input_dim=self.Xdim,
output_dim=self.num_output_funcs,
rank=1,
kernels_list=self.kern_list,
W_list=self.W_list,
kappa_list=self.kappa_list)
# Set-up optimization parameters: [Z, m_u, L_u]
self.q_u_means = Param(
'm_u',
0.0 * np.random.randn(self.num_inducing, self.num_latent_funcs) +
0.0 * np.tile(np.random.randn(1, self.num_latent_funcs),
(self.num_inducing, 1)))
chols = choleskies.triang_to_flat(
np.tile(
np.eye(self.num_inducing)[None, :, :],
(self.num_latent_funcs, 1, 1)))
self.q_u_chols = Param('L_u', chols)
self.link_parameter(self.Z, index=0)
self.link_parameter(self.q_u_means)
self.link_parameters(self.q_u_chols)
[self.link_parameter(kern_q)
for kern_q in kern_list] # link all kernels
[self.link_parameter(B_q) for B_q in self.B_list]
self.vem_step = True # [True=VE-step, False=VM-step]
self.ve_count = 0
self.elbo = np.zeros((1, 1))
self.index_VEM = 0 #this is a variable to index correctly the self.elbo when using VEM
self.Gauss_Newton = False #This is a flag for using the Gauss-Newton approximation when dL_dV is needed
def __init__(self, variance, degree=2, name='parabola'):
super(Parabola, self).__init__(1, 1, name)
self.variance = Param('variance',
np.ones(degree + 1) * variance)
self.degree = degree
self.link_parameter(self.variance)
def __init__(self, kernel=None, dL_dK=None, X=None, X2=None):
Kern_check_model.__init__(self, kernel=kernel, dL_dK=dL_dK, X=X, X2=X2)
self.X = Param('X', X)
self.link_parameter(self.X)
def __init__(self,
Y,
input_dim,
X=None,
X_variance=None,
init='PCA',
num_inducing=10,
Z=None,
kernel=None,
inference_method=None,
likelihood=None,
name='bayesian gplvm',
normalizer=None,
missing_data=False,
stochastic=False,
batchsize=1):
self.logger = logging.getLogger(self.__class__.__name__)
if X is None:
from ..util.initialization import initialize_latent
self.logger.info(
"initializing latent space X with method {}".format(init))
X, fracs = initialize_latent(init, input_dim, Y)
else:
fracs = np.ones(input_dim)
self.init = init
if Z is None:
self.logger.info("initializing inducing inputs")
Z = np.random.permutation(X.copy())[:num_inducing]
assert Z.shape[1] == X.shape[1]
if X_variance == False:
self.logger.info('no variance on X, activating sparse GPLVM')
X = Param("latent space", X)
elif X_variance is None:
self.logger.info(
"initializing latent space variance ~ uniform(0,.1)")
X_variance = np.random.uniform(0, .1, X.shape)
self.variational_prior = NormalPrior()
X = NormalPosterior(X, X_variance)
if kernel is None:
self.logger.info("initializing kernel RBF")
kernel = kern.RBF(
input_dim, lengthscale=1. / fracs,
ARD=True) #+ kern.Bias(input_dim) + kern.White(input_dim)
if likelihood is None:
likelihood = Gaussian()
self.kl_factr = 1.
if inference_method is None:
from ..inference.latent_function_inference.var_dtc import VarDTC
self.logger.debug("creating inference_method var_dtc")
inference_method = VarDTC(
limit=1 if not missing_data else Y.shape[1])
if kernel.useGPU and isinstance(inference_method, VarDTC_GPU):
kernel.psicomp.GPU_direct = True
super(BayesianGPLVMMiniBatch,
self).__init__(X,
Y,
Z,
kernel,
likelihood=likelihood,
name=name,
inference_method=inference_method,
normalizer=normalizer,
missing_data=missing_data,
stochastic=stochastic,
batchsize=batchsize)
self.X = X
self.link_parameter(self.X, 0)
def __init__(self,
X,
Y,
Z,
kern_list_uq,
kern_list_Gx,
kern_list_Tq,
likelihood,
Y_metadata,
name='ConvHetMOGP_VIK',
batch_size=None):
self.batch_size = batch_size
self.kern_list = kern_list_uq
self.likelihood = likelihood
self.Y_metadata = Y_metadata
self.kern_list_Gdj = kern_list_Gx
self.kern_list_Tq = kern_list_Tq
self.num_inducing = Z.shape[0] # M
self.num_latent_funcs = len(kern_list_uq) # Q
self.num_output_funcs = likelihood.num_output_functions(
self.Y_metadata) #This is the number J in the paper
self.W_list, self.kappa_list = util.random_W_kappas(
self.num_latent_funcs, self.num_output_funcs, rank=1)
check_ARD_uq = [kern.lengthscale.shape[0] > 1 for kern in kern_list_uq]
check_ARD_Gx = [
kern.lengthscale.shape[0] > 1 for kern in kern_list_Gx
] # This is just to verify Automatic Relevance Determination
check_ARD_Tq = [kern.lengthscale.shape[0] > 1 for kern in kern_list_Tq]
if (sum(check_ARD_uq) == 0) and (sum(check_ARD_Gx)
== 0) and (sum(check_ARD_Tq) == 0):
isARD = False
elif (sum(check_ARD_uq) == check_ARD_uq.__len__()) and (
sum(check_ARD_Gx)
== check_ARD_Gx.__len__()) and (sum(check_ARD_Tq)
== check_ARD_Tq.__len__()):
isARD = True
else:
print(
'\nAll kernel_lists for Uq, Gx and Tx have to coincide in Automatic Relevance Determination,'
)
print('All kernel_lists have to coincide: ARD=True or ARD=False\n')
assert (sum(check_ARD_uq) == check_ARD_uq.__len__()) and (
sum(check_ARD_Gx)
== check_ARD_Gx.__len__()) and (sum(check_ARD_Tq)
== check_ARD_Tq.__len__())
self.kern_aux = GPy.kern.RBF(
input_dim=Z.shape[1],
lengthscale=1.0,
variance=1.0,
name='rbf_aux',
ARD=isARD) + GPy.kern.White(input_dim=Z.shape[1])
self.kern_aux.white.variance = 1e-6
self.Xmulti = X
self.Ymulti = Y
# Batch the data
self.Xmulti_all, self.Ymulti_all = X, Y
if batch_size is None:
#self.stochastic = False
Xmulti_batch, Ymulti_batch = X, Y
else:
# Makes a climin slicer to make drawing minibatches much quicker
#self.stochastic = False #"This was True as Pablo had it"
self.slicer_list = []
[
self.slicer_list.append(
draw_mini_slices(Xmulti_task.shape[0], self.batch_size))
for Xmulti_task in self.Xmulti
]
Xmulti_batch, Ymulti_batch = self.new_batch()
self.Xmulti, self.Ymulti = Xmulti_batch, Ymulti_batch
# Initialize inducing points Z
self.Xdim = Z.shape[1]
Z = np.tile(Z, (1, self.num_latent_funcs))
inference_method = SVMOGPInf()
super(ConvHetMOGP_VIK,
self).__init__(X=Xmulti_batch[0][1:10],
Y=Ymulti_batch[0][1:10],
Z=Z,
kernel=kern_list_uq[0],
likelihood=likelihood,
mean_function=None,
X_variance=None,
inference_method=inference_method,
Y_metadata=Y_metadata,
name=name,
normalizer=False)
self.unlink_parameter(
self.kern) # Unlink SparseGP default param kernel
_, self.B_list = util.LCM(input_dim=self.Xdim,
output_dim=self.num_output_funcs,
rank=1,
kernels_list=self.kern_list,
W_list=self.W_list,
kappa_list=self.kappa_list)
# Set-up optimization parameters: [Z, m_u, L_u]
self.q_u_means = [
Param(
'm_u' + str(dj), 10.0 *
np.random.randn(self.num_inducing, self.num_latent_funcs) +
10.0 * np.tile(np.random.randn(1, self.num_latent_funcs),
(self.num_inducing, 1)))
for dj in range(self.num_output_funcs)
]
chols = choleskies.triang_to_flat(
np.tile(3 * np.eye(self.num_inducing)[None, :, :],
(self.num_latent_funcs, 1, 1)))
self.q_u_chols = Param('L_u', chols)
self.link_parameter(self.Z, index=0)
[self.link_parameter(q_u_means) for q_u_means in self.q_u_means]
self.link_parameters(self.q_u_chols)
[self.link_parameter(kern_q)
for kern_q in kern_list_uq] # link all kernels
[self.link_parameter(B_q) for B_q in self.B_list]
[self.link_parameter(kern_list_Gjd) for kern_list_Gjd in kern_list_Gx]
[self.link_parameter(kern_list_Tq) for kern_list_Tq in kern_list_Tq]
#self.link_parameter(self.kern_aux.white.variance)
self.vem_step = True # [True=VE-step, False=VM-step]
self.ve_count = 0
self.elbo = np.zeros((1, 1))
self.index_VEM = 0 #this is a variable to index correctly the self.elbo when using VEM
self.Gauss_Newton = False #This is a flag for using the Gauss-Newton approximation when dL_dV is needed
for kern_q in self.kern_list:
kern_q.variance = 1.0
kern_q.variance.fix()
for kern_Gjd in self.kern_list_Gdj:
kern_Gjd.variance = 1.0
kern_Gjd.variance.fix()
#print('IN fix Gdj')
for kern_Tq in self.kern_list_Tq:
kern_Tq.variance = 1.0
kern_Tq.variance.fix()
def __init__(self, input_dim, alp=1.0, bet=1.0, active_dims=None):
super(ExpKernel, self).__init__(input_dim, active_dims, 'exp kernel')
assert input_dim == 1, "For this kernel we assume input_dim=1"
self.alp = Param("alp", alp)
self.bet = Param("bet", bet)
self.link_parameters(self.alp, self.bet)
