def __init__(self,
X,
Y,
likelihood,
layers,
minibatch_size=None,
num_samples=1,
num_data=None,
**kwargs):
"""
Base class for the fully coupled DGP providing all basic functionalities.
"""
Model.__init__(self, **kwargs)
self.num_samples = num_samples
self.num_data = num_data or X.shape[0]
if minibatch_size:
self.X = Minibatch(X, minibatch_size, seed=0)
self.Y = Minibatch(Y, minibatch_size, seed=0)
else:
self.X = DataHolder(X)
self.Y = DataHolder(Y)
self.likelihood = likelihood
self.layers = layers
def __init__(self,
X,
Y,
W,
kern,
feat=None,
mean_function=None,
Z=None,
**kwargs):
"""
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)
Y = DataHolder(Y)
likelihood = likelihoods.Gaussian()
GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
self.feature = features.inducingpoint_wrapper(feat, Z)
self.num_data = X.shape[0]
self.W_prior = tf.ones(W.shape, dtype=settings.float_type) / W.shape[1]
self.W = Parameter(W)
self.num_inducing = Z.shape[0] * W.shape[1]
def __init__(self,
X,
Y,
Z,
kern,
likelihood,
mean_function=Zero,
minibatch_size=None,
num_latent=None,
num_samples=1,
num_data=None,
whiten=True):
Model.__init__(self)
self.num_samples = num_samples
self.num_latent = num_latent or Y.shape[1]
self.num_data = num_data or X.shape[0]
if minibatch_size:
self.X = Minibatch(X, minibatch_size, seed=0)
self.Y = Minibatch(Y, minibatch_size, seed=0)
else:
self.X = DataHolder(X)
self.Y = DataHolder(Y)
self.likelihood = likelihood
assert isinstance(likelihood, HeteroscedasticLikelihood)
self.f_latent = Latent(Z,
mean_function,
kern,
num_latent=num_latent,
whiten=whiten,
name="f_latent")
def __init__(self,
X,
Y,
Z,
layers,
likelihood,
num_latent=None,
minibatch_size=None,
num_samples=1,
mean_function=Zero(),
name=None):
"""
- X is a data matrix, size N x D.
- Y is a data matrix, size N x R.
- Z is a matrix of inducing inputs, size M x D.
- layers is an instance of Sequential containing the layer structure of
the DGP.
- likelihood is an instance of the gpflow likehood object.
- num_latent_Y is the number of latent processes to use.
- minibatch_size, if not None turns of minibatching with that size.
- num_samples is the number of Monte Carlo samples to use.
- mean_function is an instance of the gpflow mean_function object,
corresponds to the mean function of the final layer.
- name is the name of the TensforFlow object.
"""
super(DSDGP, self).__init__(name=name)
assert X.shape[0] == Y.shape[0]
assert Z.shape[1] == X.shape[1]
self.num_data, D_X = X.shape
self.num_samples = num_samples
self.D_Y = num_latent or Y.shape[1]
self.mean_function = mean_function
layers.initialize_params(X,
Z) #Maybe add initialization method for model
if layers._initialized == True:
self.layers = layers
else:
raise ValueError("Layers were not initialized")
self.dims = self.layers.get_dims()
self.likelihood = likelihood
if minibatch_size is None:
X = DataHolder(X)
Y = DataHolder(Y)
else:
X = Minibatch(X, batch_size=minibatch_size, seed=0)
Y = Minibatch(Y, batch_size=minibatch_size, seed=0)
self.X, self.Y = X, Y
def __init__(self, X, Y, kern, mean_function=None, **kwargs):
"""
X is a data matrix, size N x D
Y is a data matrix, size N x R
kern, mean_function are appropriate GPflow objects
"""
likelihood = likelihoods.Gaussian()
X = DataHolder(X)
Y = DataHolder(Y)
GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
def __init__(self,
X,
Y,
kern,
minibatch_size=None,
n_filters=256,
name: str = None):
super(ConvNet, self).__init__(name=name)
if not hasattr(kern, 'W_'):
# Create W_ and b_ as attributes in kernel
X_zeros = np.zeros([1] + kern.input_shape)
_ = kern.equivalent_BNN(X=tf.constant(X_zeros,
dtype=settings.float_type),
n_samples=1,
n_filters=n_filters)
self._kern = kern
# Make MiniBatches if necessary
if minibatch_size is None:
self.X = DataHolder(X)
self.Y = DataHolder(Y, dtype=tf.int32)
self.scale_factor = 1.
else:
self.X = Minibatch(X, batch_size=minibatch_size, seed=0)
self.Y = Minibatch(Y,
batch_size=minibatch_size,
seed=0,
dtype=np.int32)
self.scale_factor = X.shape[0] / minibatch_size
self.n_labels = int(np.max(Y) + 1)
# Create GPFlow parameters with the relevant size of the network
Ws, bs = [], []
for i, (W, b) in enumerate(zip(kern._W, kern._b)):
if i == kern.n_layers:
W_shape = [int(W.shape[1]), self.n_labels]
b_shape = [self.n_labels]
else:
W_shape = list(map(int, W.shape[1:]))
b_shape = [n_filters]
W_var = kern.var_weight.read_value() / W_shape[-2]
b_var = kern.var_bias.read_value()
W_init = np.sqrt(W_var) * np.random.randn(*W_shape)
b_init = np.sqrt(b_var) * np.random.randn(*b_shape)
Ws.append(
gpflow.params.Parameter(W_init, dtype=settings.float_type)
) #, prior=ZeroMeanGauss(W_var)))
bs.append(
gpflow.params.Parameter(b_init, dtype=settings.float_type)
) #, prior=ZeroMeanGauss(b_var)))
self.Ws = gpflow.params.ParamList(Ws)
self.bs = gpflow.params.ParamList(bs)
def __init__(self,
X,
Y,
kern,
likelihood,
feat=None,
mean_function=None,
num_latent=None,
q_diag=False,
whiten=True,
minibatch_size=None,
Z=None,
num_data=None,
q_mu=None,
q_sqrt=None,
**kwargs):
"""
- X is a data matrix, size N x D
- Y is a data matrix, size N x P
- kern, likelihood, mean_function are appropriate GPflow objects
- Z is a matrix of pseudo inputs, size M x D
- num_latent is the number of latent process to use, defaults to one.
- q_diag is a boolean. If True, the covariance is approximated by a
diagonal matrix.
- whiten is a boolean. If True, we use the whitened representation of
the inducing points.
- minibatch_size, if not None, turns on mini-batching with that size.
- num_data is the total number of observations, default to X.shape[0]
(relevant when feeding in external minibatches)
"""
# sort out the X, Y into MiniBatch objects if required.
if minibatch_size is None:
X = DataHolder(X)
Y = DataHolder(Y)
else:
X = Minibatch(X, batch_size=minibatch_size, seed=0)
Y = Minibatch(Y, batch_size=minibatch_size, seed=0)
# init the super class, accept args
if num_latent is None:
num_latent = 1
GPModel.__init__(self, X, Y, kern, likelihood, mean_function,
num_latent, **kwargs)
self.num_data = num_data or X.shape[0]
self.num_classes = X.shape[1]
self.q_diag, self.whiten = q_diag, whiten
self.feature = features.inducingpoint_wrapper(feat, Z)
# init variational parameters
num_inducing = len(self.feature)
self._init_variational_parameters(num_inducing, q_mu, q_sqrt, q_diag)
def __init__(self, x, y, kern, mean_function=None, **kwargs):
"""
X is a data matrix, size N x D
Y is a data matrix, size N x R
kern, mean_function are appropriate GPflow objects
"""
likelihood = likelihoods.Gaussian()
x = [DataHolder(x_i) for x_i in x]
y = DataHolder(y)
print(x)
print(y)
print(kern)
super().__init__(x, y, kern, likelihood, mean_function, **kwargs)
def __init__(self, Y_var, freqs, *args, **kwargs):
minibatch_size = kwargs.get('minibatch_size', None)
if minibatch_size is None:
Y_var = DataHolder(Y_var)
freqs = DataHolder(freqs)
else:
Y_var = Minibatch(Y_var, batch_size=minibatch_size, seed=0)
freqs = Minibatch(freqs, batch_size=minibatch_size, seed=0)
super(HeteroscedasticPhaseOnlySVGP, self).__init__(*args, **kwargs)
self.Y_var = Y_var
self.freqs = freqs
def __init__(self,
X,
Y,
likelihood,
layers,
minibatch_size=None,
num_samples=1,
**kwargs):
"""
:param X: List of training inputs where each element of the list is a numpy array corresponding to the inputs of one fidelity.
:param Y: List of training targets where each element of the list is a numpy array corresponding to the inputs of one fidelity.
:param likelihood: gpflow likelihood object for use at the final layer
:param layers: List of doubly_stochastic_dgp.layers.Layer objects
:param minibatch_size: Minibatch size if using minibatch trainingz
:param num_samples: Number of samples when propagating predictions through layers
:param kwargs: kwarg inputs to gpflow.models.Model
"""
Model.__init__(self, **kwargs)
self.Y_list = Y
self.X_list = X
self.minibatch_size = minibatch_size
self.num_samples = num_samples
# This allows a training regime where the first layer is trained first by itself, then the subsequent layer
# and so on.
self._train_upto_fidelity = -1
if minibatch_size:
for i, (x, y) in enumerate(zip(X, Y)):
setattr(self, "num_data" + str(i), x.shape[0])
setattr(self, "X" + str(i), Minibatch(x,
minibatch_size,
seed=0))
setattr(self, "Y" + str(i), Minibatch(y,
minibatch_size,
seed=0))
else:
for i, (x, y) in enumerate(zip(X, Y)):
setattr(self, "num_data" + str(i), x.shape[0])
setattr(self, "X" + str(i), DataHolder(x))
setattr(self, "Y" + str(i), DataHolder(y))
self.num_layers = len(layers)
self.layers = ParamList(layers)
self.likelihood = BroadcastingLikelihood(likelihood)
def __init__(self, X, Y, kern, mean_function=None, minibatch_size=None, seed=0, **kwargs): likelihood = likelihoods.Gaussian() self._seed = seed self._minibatch_size = minibatch_size self._N = X.shape[0] if len(X.shape) >= 3: X = X.reshape((-1, np.prod(np.array(list(X.shape)[1:])))) if minibatch_size is None: X = DataHolder(X) Y = DataHolder(Y) self._iters_per_epoch = 1 else: X = Minibatch(X, batch_size=self._N, shuffle=True, seed=seed) Y = Minibatch(Y, batch_size=self._N, shuffle=True, seed=seed) self._iters_per_epoch = self._N//minibatch_size + min(1, self._N%minibatch_size) GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
def __init__(self,
t,
XExpanded,
Y,
kern,
indices,
b,
ZExpanded,
fDebug=False,
phiInitial=None,
phiPrior=None):
assigngp_dense.AssignGP.__init__(self,
t,
XExpanded,
Y,
kern,
indices,
b,
fDebug=fDebug,
phiInitial=phiInitial,
phiPrior=phiPrior)
# Do not treat inducing points as parameters because they should always be fixed.
self.ZExpanded = DataHolder(
ZExpanded) # inducing points for sparse GP. Same as XExpanded
assert ZExpanded.shape[1] == XExpanded.shape[1]
def __init__(self,
X,
Y,
W1,
W1_index,
W2,
W2_index,
kern,
feat=None,
mean_function=None,
Z=None,
**kwargs):
"""
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
W1, size NxK
W1_index PxL
W2, size NxL
W2_index PxL
kern, mean_function are appropriate GPflow objects
This method only works with a Gaussian likelihood.
"""
X = DataHolder(X)
Y = DataHolder(Y, fix_shape=True)
likelihood = likelihoods.Gaussian()
GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
self.feature = features.inducingpoint_wrapper(feat, Z)
self.num_data = X.shape[0]
self.W1_prior = Parameter(np.log(
np.ones(W1.shape[1], dtype=settings.float_type) / W1.shape[1]),
trainable=False)
self.W1 = Parameter(W1)
self.W1_index = DataHolder(W1_index, dtype=np.int32, fix_shape=True)
self.K = W1.shape[1]
self.W2_prior = Parameter(np.log(
np.ones(W2.shape[1], dtype=settings.float_type) / W2.shape[1]),
trainable=False)
self.W2 = Parameter(W2)
self.W2_index = DataHolder(W2_index, dtype=np.int32, fix_shape=True)
self.L = W2.shape[1]
self.num_inducing = Z.shape[0]
def __init__(self, X, Y, likelihood, layers,
minibatch_size=None,
num_samples=1):
Model.__init__(self)
self.num_samples = num_samples
self.num_data = X.shape[0]
if minibatch_size:
self.X = Minibatch(X, minibatch_size, seed=0)
self.Y = Minibatch(Y, minibatch_size, seed=0)
else:
self.X = DataHolder(X)
self.Y = DataHolder(Y)
self.likelihood = BroadcastingLikelihood(likelihood)
self.layers = ParamList(layers)
def __init__(self, X, Y, W, kern, idx=None, feat=None, Z=None,
mean_function=None, q_diag=False, whiten=False,
q_mu=None, q_sqrt=None,
minibatch_size=None, num_latent=None, **kwargs):
"""
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.
"""
num_data = X.shape[0]
if minibatch_size is None:
X = DataHolder(X, fix_shape=True)
Y = DataHolder(Y, fix_shape=True)
else:
X = Minibatch(X, batch_size=minibatch_size, seed=0)
Y = Minibatch(Y, batch_size=minibatch_size, seed=0)
# init the super class
likelihood = likelihoods.Gaussian()
num_latent = W.shape[1]
GPModel.__init__(self, X, Y, kern, likelihood, mean_function,
num_latent=num_latent, **kwargs)
if minibatch_size is not None:
idx = Minibatch(np.arange(num_data), batch_size=minibatch_size, seed=0, dtype=np.int32)
self.idx = idx
self.W = Parameter(W, trainable=False)
self.K = self.W.shape[1]
self.W_prior = Parameter(np.ones(self.K) / self.K, trainable=False)
self.num_data = num_data
self.feature = features.inducingpoint_wrapper(feat, Z)
self.minibatch_size = minibatch_size
self.q_diag, self.whiten = q_diag, whiten
# init variational parameters
num_inducing = len(self.feature)
self._init_variational_parameters(
num_inducing, q_mu, q_sqrt, q_diag)
def __init__(self,Y_var,*args, **kwargs):
minibatch_size = kwargs.get('minibatch_size',None)
if minibatch_size is None:
Y_var = DataHolder(Y_var)
else:
Y_var = Minibatch(Y_var, batch_size=minibatch_size, seed=0)
super(HeteroscedasticTecSVGP, self).__init__(*args, **kwargs)
self.Y_var = Y_var
def __init__(self, weights, *args, **kwargs):
minibatch_size = kwargs.get('minibatch_size', None)
if minibatch_size is None:
weights = DataHolder(weights)
else:
weights = Minibatch(weights, batch_size=minibatch_size, seed=0)
super(HomoscedasticPhaseOnlySVGP, self).__init__(*args, **kwargs)
self.weights = weights
def __init__(self,
X,
Y,
likelihood,
layers,
minibatch_size=None,
num_samples=1,
num_data=None,
div_weights=None,
**kwargs):
Model.__init__(self, **kwargs)
self.num_samples = num_samples
self.num_data = num_data or X.shape[0]
if minibatch_size:
self.X = Minibatch(X, minibatch_size, seed=0)
self.Y = Minibatch(Y, minibatch_size, seed=0)
else:
self.X = DataHolder(X)
self.Y = DataHolder(Y)
self.likelihood = BroadcastingLikelihood(likelihood)
self.layers = ParamList(layers)
"""CHANGES START"""
"""Weights for the uncertainty quantifiers (per layer)"""
if div_weights is None:
div_weights = [1.0] * len(
layers) #multiply by 1, i.e. don't change
elif type(div_weights) == list and len(div_weights) != len(layers):
print(
"WARNING! You specified a list of weights for the " +
"uncertainty quantifiers, but your DGP has more/less layers " +
"than the number of weights you specified! " +
"We set all weights to 1.0")
div_weights = [1.0] * len(layers)
elif type(div_weights) == list and len(div_weights) == len(layers):
div_weights = div_weights
"""Distribute the weights into the layers"""
for layer, weight in zip(layers, div_weights):
layer.set_weight(weight)
"""CHANGES EEND"""
def __init__(self, base_kern, branchPtTensor, b, fDebug=False):
''' branchPtTensor is tensor of branch points of size F X F X B where F the number of
functions and B the number of branching points '''
Kernel.__init__(self, input_dim=base_kern.input_dim + 1)
self.kern = base_kern
self.fm = branchPtTensor
self.fDebug = fDebug
assert isinstance(b, np.ndarray)
assert self.fm.shape[0] == self.fm.shape[1]
assert self.fm.shape[2] > 0
self.Bv = DataHolder(b)
def __init__(self, X, Y, kern, likelihood, feat, mean_function=None, num_latent=None, q_diag=False, whiten=True, minibatch_size=None, num_data=None, q_mu=None, q_sqrt=None, shuffle=True, **kwargs):
if not isinstance(feat, InducingTensors) and not isinstance(feat, InducingSequences):
raise ValueError('feat must be of type either InducingTensors or InducingSequences')
num_inducing = len(feat)
if minibatch_size is None:
X = DataHolder(X)
Y = DataHolder(Y)
else:
X = Minibatch(X, batch_size=minibatch_size, shuffle=shuffle, seed=0)
Y = Minibatch(Y, batch_size=minibatch_size, shuffle=shuffle, seed=0)
models.GPModel.__init__(self, X, Y, kern, likelihood, mean_function, num_latent, **kwargs)
self.num_data = num_data or X.shape[0]
self.q_diag, self.whiten = q_diag, whiten
self.feature = feat
self._init_variational_parameters(num_inducing, q_mu, q_sqrt, q_diag)
return
def __init__(self, X, Y, layers, minibatch_size=None, seed=0, **kwargs):
likelihood = likelihoods.delta()
self._seed = seed
self._minibatch_size = minibatch_size
self._N = X.shape[0]
if len(X.shape) >= 3:
X = X.reshape((-1, np.prod(np.array(list(X.shape)[1:]))))
if minibatch_size is None:
X = DataHolder(X)
Y = DataHolder(Y)
self._iters_per_epoch = 1
else:
X = Minibatch(X, batch_size=self._N, shuffle=True, seed=seed)
Y = Minibatch(Y, batch_size=self._N, shuffle=True, seed=seed)
self._iters_per_epoch = self._N // minibatch_size + min(
1, self._N % minibatch_size)
GPModel.__init__(self, X, Y, None, likelihood, None, **kwargs)
self.layers = []
for i, layer in enumerate(layers):
setattr(self, "layer_" + str(i), layer)
self.layers.append(getattr(self, "layer_" + str(i)))
def __init__(self, Y_var=None,var=1.0, trainable=True,minibatch_size=None):
super().__init__()
self.variance = Parameter(
var, transform=transforms.positive, dtype=settings.float_type, trainable=trainable)
if Y_var is None:
self.relative_variance = 1.0
else:
if minibatch_size is None:
self.relative_variance = DataHolder(Y_var[:,None]+1e-3)
else:
self.relative_variance = Minibatch(Y_var[:,None]+1e-3, batch_size=minibatch_size, shuffle=True, seed=0)
def __init__(self, X, Y, kern, Z=None, Zy=None,Zvar = None,mean_function=None, minibatch_size=None, var = 1.0, shuffle=True, trainable_var=True,**kwargs):
"""
X is a data matrix, size N x D
Y is a data matrix, size N x R
kern, mean_function are appropriate GPflow objects
minibatch_size, if not None, turns on mini-batching with that size.
vector_obs_variance if not None (default) is vectorized measurement variance
"""
Z = DataHolder(Z) if (Z is not None) and (Zy is not None) and (Zvar is not None) else None
Zy = DataHolder(Zy) if (Z is not None) and (Zy is not None) and (Zvar is not None) else None
Zvar = DataHolder(Zvar) if (Z is not None) and (Zy is not None) and (Zvar is not None) else None
if minibatch_size is None:
X = DataHolder(X)
Y = DataHolder(Y)
Y_var = DataHolder(var)
else:
X = Minibatch(X, batch_size=minibatch_size, shuffle=shuffle, seed=0)
Y = Minibatch(Y, batch_size=minibatch_size, shuffle=shuffle, seed=0)
Y_var = Minibatch(var, batch_size=minibatch_size, shuffle=shuffle, seed=0)
likelihood = Gaussian_v2(var=1.0,trainable=trainable_var)
likelihood.relative_variance = Y_var
GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
self.Z = Z
self.Zy = Zy
self.Zvar = Zvar
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]
X = gpflow.params.Minibatch(X, minibatch_size, np.random.RandomState(0))
Y = gpflow.params.Minibatch(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 = Parameter(Z)
self.num_latent = num_latent or Y.shape[1]
self.num_inducing = Z.shape[0]
self.num_data = X.shape[0]
self._init_variational_parameters(num_inducing=self.num_inducing, q_mu=None, q_sqrt=None, q_diag=self.q_diag)
self.mu_old = DataHolder(mu_old)
self.M_old = Z_old.shape[0]
self.Su_old = DataHolder(Su_old)
self.Kaa_old = DataHolder(Kaa_old)
self.Z_old = DataHolder(Z_old)
def __init__(self,
X,
Y,
kern,
likelihood,
mean_function,
num_latent=None,
name=None):
super(GPModel, self).__init__(name=name)
self.num_latent = num_latent or Y.shape[1]
self.mean_function = mean_function or Zero(output_dim=self.num_latent)
self.kern = kern
self.likelihood = likelihood
if isinstance(X, np.ndarray):
# X is a data matrix; each row represents one instance
X = DataHolder(X)
if isinstance(Y, np.ndarray):
# Y is a data matrix, rows correspond to the rows in X,
# columns are treated independently
Y = DataHolder(Y)
self.X, self.Y = X, Y
def __init__(self,
X_target,
Y_target,
X_source,
Y_source,
kern,
source_likelihood_variance,
mean_function=None,
b=1.0,
mu=1.0,
**kwargs):
"""
:param X_target: Input data matrix of size NxD
:param Y_target: Output data matrix of size NxR
:param X_source: Input data matrix of size NxD
:param Y_source: Output data matrix of size NxR
:param kern: GPflow kernel object
:param mean_function: GPflow mean_function object
:param b: Initial value for transfer param b (float)
:param mu: Initial value for transfer param mu (float)
:param kwargs: Additional keyword arguments
"""
target_likelihood = Gaussian()
super(ATGPR, self).__init__(X_target,
Y_target,
kern,
target_likelihood,
mean_function,
**kwargs)
self.source_likelihood = Gaussian(source_likelihood_variance)
self.source_likelihood.variance.trainable = False
self.X_source = DataHolder(X_source)
self.Y_source = DataHolder(Y_source)
self.b = Parameter(b, transform=Log1pe(), dtype=settings.float_type)
self.mu = Parameter(mu, transform=Log1pe(), dtype=settings.float_type)
def __init__(self, X, Y, latent_dim, layers, batch_size=64, name=None):
super().__init__(name=name)
self.X_dim = X.shape[1]
self.Y_dim = Y.shape[1] # the conditions
X = X.astype(np.float32)
Y = Y.astype(np.float32)
if batch_size is not None:
self.X = Minibatch(X, batch_size=batch_size, seed=0)
self.Y = Minibatch(Y, batch_size=batch_size, seed=0)
else:
self.X = DataHolder(X)
self.Y = DataHolder(Y)
self.latent_dim = latent_dim
self.variance = Parameter(.05, transform=transforms.positive)
self.batch_size = batch_size
shape = (X.shape[0], latent_dim) if (batch_size is None) else (batch_size, latent_dim)
self.prior_z = tf.distributions.Normal(loc=tf.zeros(shape, dtype=tf.float32),
scale=tf.cast(1.0, dtype=tf.float32))
self._build_encoder(layers)
self._build_decoder(layers)
def __init__(self,
t,
XExpanded,
Y,
kern,
indices,
b,
phiPrior=None,
phiInitial=None,
fDebug=False,
KConst=None):
GPModel.__init__(self,
XExpanded,
Y,
kern,
likelihood=gpflow.likelihoods.Gaussian(),
mean_function=Zero())
assert len(indices) == t.size, 'indices must be size N'
assert len(t.shape) == 1, 'pseudotime should be 1D'
self.N = t.shape[0]
self.t = t.astype(
settings.float_type) # could be DataHolder? advantages
self.indices = indices
self.logPhi = Parameter(np.random.randn(
t.shape[0], t.shape[0] * 3)) # 1 branch point => 3 functions
if (phiInitial is None):
phiInitial = np.ones((self.N, 2)) * 0.5 # dont know anything
phiInitial[:, 0] = np.random.rand(self.N)
phiInitial[:, 1] = 1 - phiInitial[:, 0]
self.fDebug = fDebug
# Used as p(Z) prior in KL term. This should add to 1 but will do so after UpdatePhPrior
if (phiPrior is None):
phiPrior = np.ones((self.N, 2)) * 0.5
# Fix prior term - this is without trunk
self.pZ = DataHolder(np.ones((t.shape[0], t.shape[0] * 3)))
self.UpdateBranchingPoint(b, phiInitial, prior=phiPrior)
self.KConst = KConst
if (not fDebug):
assert KConst is None, 'KConst only for debugging'
def __init__(self, X, Y, kern, mean_function=None, i=None, **kwargs):
likelihood = likelihoods.Gaussian()
X = DataHolder(X)
Y = DataHolder(Y)
GPModel.__init__(self, X, Y, kern, likelihood, mean_function, **kwargs)
self.i = i
def __init__(self,
X,
Y,
kern,
likelihood,
mean_function=None,
feat=None,
Z=None,
q_diag=False,
whiten=True,
minibatch_size=None,
num_data=None,
num_latent=None,
q_mu=None,
q_sqrt=None,
alpha=None,
alpha_tilde=None,
**kwargs):
"""
- X is a data matrix, size N x D
- Y contains the annotations. It is a numpy array of matrices with 2 columns, gathering pairs (annotator, annotation).
- kern, likelihood, mean_function are appropriate GPflow objects
- feat and Z define the pseudo inputs, usually feat=None and Z size M x D
- q_diag, boolean indicating whether posterior covariance must be diagonal
- withen, boolean indicating whether a whitened representation of the inducing points is used
- minibatch_size, if not None, turns on mini-batching with that size
- num_data is the total number of observations, default to X.shape[0] (relevant when feeding in external minibatches)
- num_latent is the number of latent GP to be used. For multi-class likelihoods, this equals the number of classes. However, for many binary likelihoods, num_latent=1.
- q_mu (M x K), q_sqrt (M x K or K x M x M), alpha (A x K x K), alpha_tilde (A x K x K), initializations for these parameters (all of them but alpha to be estimated).
"""
if minibatch_size is None:
X = DataHolder(X)
else:
X = Minibatch(X, batch_size=minibatch_size, seed=0)
class_keys = np.unique(np.concatenate([y[:, 1] for y in Y]))
num_classes = len(class_keys)
num_latent = num_latent or num_classes
GPModel.__init__(self, X, None, kern, likelihood, mean_function,
num_latent, **kwargs)
self.class_keys = class_keys
self.num_classes = num_classes
self.num_latent = num_latent
self.annot_keys = np.unique(np.concatenate([y[:, 0] for y in Y]))
self.num_annotators = len(self.annot_keys)
self.num_data = num_data or X.shape[0]
self.q_diag, self.whiten = q_diag, whiten
self.feature = features.inducingpoint_wrapper(feat, Z)
self.num_inducing = len(self.feature)
###### Initializing Y_idxs as minibatch or placeholder (and the associated idxs to slice q_unn) ######################
startTime = time.time()
Y_idxs = np.array([
np.stack((np.array(
[np.flatnonzero(v == self.annot_keys)[0] for v in y[:, 0]]),
np.array([
np.flatnonzero(v == self.class_keys)[0]
for v in y[:, 1]
])),
axis=1) for y in Y
]) # same as Y but with indexes
S = np.max([v.shape[0] for v in Y_idxs])
###########################################
## pmr modification for CPU
#Y_idxs_cr = np.array([np.concatenate((y,-1*np.ones((S-y.shape[0],2))),axis=0) for y in Y_idxs]).astype(np.int16) # NxSx2
aux = np.array([self.num_annotators, 0])
Y_idxs_cr = np.array([
np.concatenate((y, np.tile(aux, (S - y.shape[0], 1))), axis=0)
for y in Y_idxs
]).astype(np.int16) # NxSx2
###########################################
if minibatch_size is None:
self.Y_idxs_cr = DataHolder(Y_idxs_cr)
self.idxs_mb = DataHolder(np.arange(self.num_data))
else:
self.Y_idxs_cr = Minibatch(Y_idxs_cr,
batch_size=minibatch_size,
seed=0)
self.idxs_mb = Minibatch(np.arange(self.num_data),
batch_size=minibatch_size,
seed=0)
print("Time taken in Y_idxs creation:", time.time() - startTime)
########## Initializing q #####################################
startTime = time.time()
q_unn = np.array(
[np.bincount(y[:, 1], minlength=self.num_classes) for y in Y_idxs])
q_unn = q_unn + np.ones(q_unn.shape)
q_unn = q_unn / np.sum(q_unn, axis=1, keepdims=True)
self.q_unn = Parameter(q_unn, transform=transforms.positive) # N x K
print("Time taken in q_unn initialization:", time.time() - startTime)
######## Initializing alpha (fix) and alpha_tilde (trainable) ################3
#if alpha is None:
# self.alpha = tf.constant(np.ones((self.num_annotators,self.num_classes,self.num_classes), dtype=settings.float_type)) # A x K x K
#else:
# self.alpha = tf.constant(alpha, dtype=settings.float_type) # A x K x K
if alpha is None:
alpha = np.ones(
(self.num_annotators, self.num_classes, self.num_classes),
dtype=settings.float_type) # A x K x K
self.alpha = Parameter(alpha,
transform=transforms.positive,
trainable=False)
startTime = time.time()
alpha_tilde = self._init_behaviors(q_unn, Y_idxs)
print("Time taken in alpha_tilde initialization:",
time.time() - startTime)
self.alpha_tilde = Parameter(
alpha_tilde, transform=transforms.positive) # A x K x K
################################################################################
##### Initializing the variational parameters ####################################
self._init_variational_parameters(q_mu, q_sqrt)
