def __init__(self, dim, input_dim=0, kern=None, Z=None, n_ind_pts=100,
mean_fn=None, Q_diag=None, Umu=None, Ucov_chol=None,
jitter=gps.numerics.jitter_level, name=None):
super().__init__(name=name)
self.OBSERVATIONS_AS_INPUT = False
self.dim = dim
self.input_dim = input_dim
self.jitter = jitter
self.Q_sqrt = Param(np.ones(self.dim) if Q_diag is None else Q_diag ** 0.5, transform=gtf.positive)
self.n_ind_pts = n_ind_pts if Z is None else (Z[0].shape[-2] if isinstance(Z, list) else Z.shape[-2])
if isinstance(Z, np.ndarray) and Z.ndim == 2:
self.Z = mf.SharedIndependentMof(gp.features.InducingPoints(Z))
else:
Z_list = [np.random.randn(self.n_ind_pts, self.dim + self.input_dim)
for _ in range(self.dim)] if Z is None else [z for z in Z]
self.Z = mf.SeparateIndependentMof([gp.features.InducingPoints(z) for z in Z_list])
if isinstance(kern, gp.kernels.Kernel):
self.kern = mk.SharedIndependentMok(kern, self.dim)
else:
kern_list = kern or [gp.kernels.Matern32(self.dim + self.input_dim, ARD=True) for _ in range(self.dim)]
self.kern = mk.SeparateIndependentMok(kern_list)
self.mean_fn = mean_fn or mean_fns.Identity(self.dim)
self.Umu = Param(np.zeros((self.dim, self.n_ind_pts)) if Umu is None else Umu) # Lm^-1(Umu - m(Z))
transform = gtf.LowerTriangular(self.n_ind_pts, num_matrices=self.dim, squeeze=False)
self.Ucov_chol = Param(np.tile(np.eye(self.n_ind_pts)[None, ...], [self.dim, 1, 1])
if Ucov_chol is None else Ucov_chol, transform=transform) # Lm^-1(Ucov_chol)
self._Kzz = None
def identity_mean():
# Note: Identity can only be used if Din == Dout
return mean_functions.Identity(input_dim=Data.D_in)
Z = rng.randn(num_ind, D_in)
def markov_gauss():
cov_params = rng.randn(num_data + 1, D_in, 2 * D_in) / 2.0 # (N+1)xDx2D
Xcov = cov_params @ np.transpose(cov_params, (0, 2, 1)) # (N+1)xDxD
Xcross = cov_params[:-1] @ np.transpose(cov_params[1:], (0, 2, 1)) # NxDxD
Xcross = np.concatenate((Xcross, np.zeros((1, D_in, D_in))),
0) # (N+1)xDxD
Xcov = np.stack([Xcov, Xcross]) # 2x(N+1)xDxD
return MarkovGaussian(Xmu_markov, ctt(Xcov))
_means = {
"lin": mf.Linear(A=rng.randn(D_in, D_out), b=rng.randn(D_out)),
"identity": mf.Identity(input_dim=D_in),
"const": mf.Constant(c=rng.randn(D_out)),
"zero": mf.Zero(output_dim=D_out),
}
_distrs = {
"gauss":
Gaussian(Xmu, Xcov),
"dirac_gauss":
Gaussian(Xmu, np.zeros((num_data, D_in, D_in))),
"gauss_diag":
DiagonalGaussian(Xmu, rng.rand(num_data, D_in)),
"dirac_diag":
DiagonalGaussian(Xmu, np.zeros((num_data, D_in))),
"dirac_markov_gauss":
MarkovGaussian(Xmu_markov, np.zeros((2, num_data + 1, D_in, D_in))),
def identity():
# Note: Identity can only be used if Din == Dout
return mean_functions.Identity(Data.D_in)
Z = rng.randn(num_ind, D_in)
def markov_gauss():
cov_params = rng.randn(num_data + 1, D_in, 2 * D_in) / 2. # (N+1)xDx2D
Xcov = cov_params @ np.transpose(cov_params, (0, 2, 1)) # (N+1)xDxD
Xcross = cov_params[:-1] @ np.transpose(cov_params[1:], (0, 2, 1)) # NxDxD
Xcross = np.concatenate((Xcross, np.zeros((1, D_in, D_in))),
0) # (N+1)xDxD
Xcov = np.stack([Xcov, Xcross]) # 2x(N+1)xDxD
return MarkovGaussian(Xmu_markov, ctt(Xcov))
_means = {
'lin': mf.Linear(A=rng.randn(D_in, D_out), b=rng.randn(D_out)),
'identity': mf.Identity(input_dim=D_in),
'const': mf.Constant(c=rng.randn(D_out)),
'zero': mf.Zero(output_dim=D_out)
}
_distrs = {
'gauss':
Gaussian(Xmu, Xcov),
'dirac_gauss':
Gaussian(Xmu, np.zeros((num_data, D_in, D_in))),
'gauss_diag':
DiagonalGaussian(Xmu, rng.rand(num_data, D_in)),
'dirac_diag':
DiagonalGaussian(Xmu, np.zeros((num_data, D_in))),
'dirac_markov_gauss':
MarkovGaussian(Xmu_markov, np.zeros((2, num_data + 1, D_in, D_in))),
def __init__(self,
latent_dim,
Y,
inputs=None,
emissions=None,
px1_mu=None,
px1_cov=None,
kern=None,
Z=None,
n_ind_pts=100,
mean_fn=None,
Q_diag=None,
Umu=None,
Ucov_chol=None,
qx1_mu=None,
qx1_cov=None,
As=None,
bs=None,
Ss=None,
n_samples=100,
seed=None,
parallel_iterations=10,
jitter=gps.numerics.jitter_level,
name=None):
super().__init__(name=name)
self.latent_dim = latent_dim
self.T, self.obs_dim = Y.shape
self.Y = Param(Y, trainable=False)
self.inputs = None if inputs is None else Param(inputs,
trainable=False)
self.input_dim = 0 if self.inputs is None else self.inputs.shape[1]
self.qx1_mu = Param(
np.zeros(self.latent_dim) if qx1_mu is None else qx1_mu)
self.qx1_cov_chol = Param(
np.eye(self.latent_dim)
if qx1_cov is None else np.linalg.cholesky(qx1_cov),
transform=gtf.LowerTriangular(self.latent_dim, squeeze=True))
self.As = Param(
np.ones((self.T - 1, self.latent_dim)) if As is None else As)
self.bs = Param(
np.zeros((self.T - 1, self.latent_dim)) if bs is None else bs)
self.Q_sqrt = Param(
np.ones(self.latent_dim) if Q_diag is None else Q_diag**0.5,
transform=gtf.positive)
if Ss is False:
self._S_chols = None
else:
self.S_chols = Param(
np.tile(self.Q_sqrt.value.copy()[None, ...], [self.T - 1, 1])
if Ss is None else
(np.sqrt(Ss) if Ss.ndim == 2 else np.linalg.cholesky(Ss)),
transform=gtf.positive if
(Ss is None or Ss.ndim == 2) else gtf.LowerTriangular(
self.latent_dim, num_matrices=self.T - 1, squeeze=False))
self.emissions = emissions or GaussianEmissions(
latent_dim=self.latent_dim, obs_dim=self.obs_dim)
self.px1_mu = Param(
np.zeros(self.latent_dim) if px1_mu is None else px1_mu,
trainable=False)
self.px1_cov_chol = None if px1_cov is None else \
Param(np.sqrt(px1_cov) if px1_cov.ndim == 1 else np.linalg.cholesky(px1_cov), trainable=False,
transform=gtf.positive if px1_cov.ndim == 1 else gtf.LowerTriangular(self.latent_dim, squeeze=True))
self.n_samples = n_samples
self.seed = seed
self.parallel_iterations = parallel_iterations
self.jitter = jitter
# Inference-specific attributes (see gpssm_models.py for appropriate choices):
nans = tf.constant(np.zeros(
(self.T, self.n_samples, self.latent_dim)) * np.nan,
dtype=gps.float_type)
self.sample_fn = lambda **kwargs: (nans, None)
self.sample_kwargs = {}
self.KL_fn = lambda *fs: tf.constant(np.nan, dtype=gps.float_type)
# GP Transitions:
self.n_ind_pts = n_ind_pts if Z is None else (
Z[0].shape[-2] if isinstance(Z, list) else Z.shape[-2])
if isinstance(Z, np.ndarray) and Z.ndim == 2:
self.Z = mf.SharedIndependentMof(gp.features.InducingPoints(Z))
else:
Z_list = [
np.random.randn(self.n_ind_pts, self.latent_dim +
self.input_dim) for _ in range(self.latent_dim)
] if Z is None else [z for z in Z]
self.Z = mf.SeparateIndependentMof(
[gp.features.InducingPoints(z) for z in Z_list])
if isinstance(kern, gp.kernels.Kernel):
self.kern = mk.SharedIndependentMok(kern, self.latent_dim)
else:
kern_list = kern or [
gp.kernels.Matern32(self.latent_dim + self.input_dim, ARD=True)
for _ in range(self.latent_dim)
]
self.kern = mk.SeparateIndependentMok(kern_list)
self.mean_fn = mean_fn or mean_fns.Identity(self.latent_dim)
self.Umu = Param(
np.zeros((self.latent_dim, self.n_ind_pts))
if Umu is None else Umu) # (Lm^-1)(Umu - m(Z))
LT_transform = gtf.LowerTriangular(self.n_ind_pts,
num_matrices=self.latent_dim,
squeeze=False)
self.Ucov_chol = Param(np.tile(
np.eye(self.n_ind_pts)[None, ...], [self.latent_dim, 1, 1])
if Ucov_chol is None else Ucov_chol,
transform=LT_transform) # (Lm^-1)Lu
self._Kzz = None
class Data:
rng = np.random.RandomState(1)
num_data = 5
num_ind = 4
D_in = 2
D_out = 2
Xmu = rng.randn(num_data, D_in)
L = gen_L(rng, num_data, D_in, D_in)
Xvar = np.array([l @ l.T for l in L])
Z = rng.randn(num_ind, D_in)
# distributions don't need to be compiled (No Parameter objects)
# but the members should be Tensors created in the same graph
graph = tf.Graph()
with test_util.session_context(graph) as sess:
gauss = Gaussian(tf.constant(Xmu), tf.constant(Xvar))
dirac = Gaussian(tf.constant(Xmu),
tf.constant(np.zeros((num_data, D_in, D_in))))
gauss_diag = DiagonalGaussian(tf.constant(Xmu),
tf.constant(rng.rand(num_data, D_in)))
dirac_diag = DiagonalGaussian(tf.constant(Xmu),
tf.constant(np.zeros((num_data, D_in))))
dirac_markov_gauss = MarkovGaussian(
tf.constant(Xmu), tf.constant(np.zeros((2, num_data, D_in, D_in))))
# create the covariance for the pairwise markov-gaussian
dummy_gen = lambda rng, n, *shape: np.array(
[rng.randn(*shape) for _ in range(n)])
L_mg = dummy_gen(rng, num_data, D_in, 2 * D_in) # N+1 x D x 2D
LL = np.concatenate((L_mg[:-1], L_mg[1:]), 1) # N x 2D x 2D
Xcov = LL @ np.transpose(LL, (0, 2, 1))
Xc = np.concatenate((Xcov[:, :D_in, :D_in], Xcov[-1:, D_in:, D_in:]),
0) # N+1 x D x D
Xcross = np.concatenate(
(Xcov[:, :D_in, D_in:], np.zeros(
(1, D_in, D_in))), 0) # N+1 x D x D
Xcc = np.stack([Xc, Xcross]) # 2 x N+1 x D x D
markov_gauss = MarkovGaussian(Xmu, Xcc)
with gpflow.decors.defer_build():
# features
ip = features.InducingPoints(Z)
# kernels
rbf_prod_seperate_dims = kernels.Product([
kernels.RBF(1,
variance=rng.rand(),
lengthscales=rng.rand(),
active_dims=[0]),
kernels.RBF(1,
variance=rng.rand(),
lengthscales=rng.rand(),
active_dims=[1])
])
rbf_lin_sum = kernels.Sum([
kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand()),
kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand()),
kernels.Linear(D_in, variance=rng.rand())
])
rbf = kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand())
lin_kern = kernels.Linear(D_in, variance=rng.rand())
# mean functions
lin = mean_functions.Linear(rng.rand(D_in, D_out), rng.rand(D_out))
iden = mean_functions.Identity(
D_in) # Note: Identity can only be used if Din == Dout
zero = mean_functions.Zero(output_dim=D_out)
const = mean_functions.Constant(rng.rand(D_out))