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)