def __init__(self, X, Y, Z, kernel, likelihood, mean_function=None, inference_method=None, name='sparse gp', Y_metadata=None, normalizer=False, mpi_comm=None, mpi_root=0, auto_update=True): self.mpi_comm = mpi_comm self.mpi_root = mpi_root self.psicov = False self.svi = False self.qU_ratio = 1. self.auto_update = auto_update if inference_method is None: from ..inference import VarDTC_parallel, VarDTC if mpi_comm is None: inference_method = VarDTC() else: inference_method = VarDTC_parallel(mpi_comm, mpi_root) elif inference_method=='inferentia' and mpi_comm is None: from ..inference import VarDTC_Inferentia inference_method = VarDTC_Inferentia() self.psicov = True elif inference_method=='svi': from ..inference import SVI_VarDTC inference_method = SVI_VarDTC() self.svi = True super(SparseGP_MPI, self).__init__(X, Y, Z, kernel, likelihood, mean_function=mean_function, inference_method=inference_method, name=name, Y_metadata=Y_metadata, normalizer=normalizer) if self.svi: from ..util.misc import comp_mapping W = comp_mapping(self.X, self.Y) qu_mean = self.Z.dot(W) self.qU_mean = Param('qU_m', qu_mean) self.qU_W = Param('qU_W', np.random.randn(Z.shape[0], Z.shape[0])*0.01) self.qU_a = Param('qU_a', 1e-3, Logexp()) self.link_parameters(self.qU_mean, self.qU_W, self.qU_a)
def test_remove_parameter(self): from GPy.core.parameterization.transformations import FIXED, UNFIXED, __fixed__, Logexp self.white.fix() self.test1.kern.unlink_parameter(self.white) self.assertIs(self.test1._fixes_, None) self.assertIsInstance(self.white.constraints, ParameterIndexOperations) self.assertListEqual(self.white._fixes_.tolist(), [FIXED]) self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops) self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops) self.test1.link_parameter(self.white, 0) self.assertIs(self.test1.constraints, self.white.constraints._param_index_ops) self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops) self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops) self.assertListEqual(self.test1.constraints[__fixed__].tolist(), [0]) self.assertIs(self.white._fixes_, None) self.assertListEqual(self.test1._fixes_.tolist(), [FIXED] + [UNFIXED] * 52) self.test1.unlink_parameter(self.white) self.assertIs(self.test1._fixes_, None) self.assertListEqual(self.white._fixes_.tolist(), [FIXED]) self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops) self.assertIs(self.test1.constraints, self.param.constraints._param_index_ops) self.assertListEqual( self.test1.constraints[Logexp()].tolist(), range(self.param.size, self.param.size + self.rbf.size))
def __init__(self, input_dim,variance=1,active_dims=[0],name="categorical", inverse=False,useGPU=False): super(Categorical, self).__init__(input_dim, active_dims, name,useGPU=useGPU) self.inverse = inverse self.variance = Param('variance',variance,Logexp()) self.link_parameter(self.variance)
def __init__(self, gp_link=None, r=1.0): if gp_link is None: #Parameterised not as link_f but as f #gp_link = Identity() gp_link = Log() super(LogLogistic, self).__init__(gp_link, name='LogLogistic') self.r = Param('r_shape', float(r), Logexp()) self.link_parameter(self.r)
def __init__(self,gp_link=None, deg_free=5, sigma2=2): if gp_link is None: gp_link = link_functions.Identity() super(HetStudentT, self).__init__(gp_link, name='Hetro_Student_T') self.v = Param('deg_free', float(deg_free), Logexp()) self.link_parameter(self.v) self.v.constrain_fixed() self.log_concave = False
def test_default_constraints(self): self.assertIs(self.rbf.variance.constraints._param_index_ops, self.rbf.constraints._param_index_ops) self.assertIs(self.test1.constraints, self.rbf.constraints._param_index_ops) self.assertListEqual(self.rbf.constraints.indices()[0].tolist(), range(2)) from GPy.core.parameterization.transformations import Logexp kern = self.test1.kern self.test1.unlink_parameter(kern) self.assertListEqual(kern.constraints[Logexp()].tolist(), range(3))
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,k1,k2,kc,xc,cpDim): if k2 is None: super(Changepoint,self).__init__([k1],"changepoint") k2 = k1 else: super(Changepoint,self).__init__([k1,k2],"changepoint") self.k1 = k1 self.k2 = k2 self.kc = Param('kc', kc, Logexp()) self.link_parameter(self.kc) self.xc = np.array(xc) self.cpDim = cpDim
def __init__(self, input_dim, basis, variance=None, ARD=False, active_dims=None, name='mean', useGP=False): """ Initialize the object. """ super(MeanFunction, self).__init__(input_dim, active_dims, name, useGP=useGP) self.input_dim = int(input_dim) self._ARD = ARD if not hasattr(basis, '__call__'): raise TypeError('The basis functions must implement the ' '\'__call__()\' method. This method should ' ' the basis functions given a 2D dimensional numpy' ' numpy array of \'num_points x input_dim\'' ' dimensions.') if not hasattr(basis, 'num_output'): raise TypeError('The basis functions must have an attribute ' ' \'num_output\' which should store the number of' ' basis functions it contains.') self._basis = basis self._num_params = basis.num_output if not ARD: if variance is None: variance = np.ones(1) else: variance = np.asarray(variance) assert variance.size == 1, 'Only 1 variance needed for a non-ARD kernel' else: if variance is not None: variance = np.asarray(variance) assert variance.size in [1, self.num_params ], 'Bad number of variances' if variance.size != self.num_params: variance = np.ones(self.num_params) * variance else: variance = np.ones(self.num_params) self.variance = Param('variance', variance, Logexp()) self.link_parameters(self.variance)
def __init__(self, layer, direction='bottom_up', encoder='mlp', encoder_dims=None, mpi_comm=None, mpi_root=0, name='encoder'): super(EncoderLayer, self).__init__(name=name) self.mpi_comm, self.mpi_root = mpi_comm, mpi_root self.layer = layer self.direction = direction if direction == 'bottom_up': self.bottom_up = True # self.X, self.Y = layer.Y, layer.X elif direction == 'top_down': self.bottom_up = False # self.X, self.Y = layer.X, layer.Y else: raise Exception( 'the argument of "direction" has to be either "bottom_up" or "top_down"!' ) self.uncertain_input = isinstance(self.X, VariationalPosterior) assert isinstance( self.Y, VariationalPosterior ), "No need to have a encoder layer for certain output!" if encoder == 'mlp': dim_in, dim_out = self.X.shape[1], self.Y.shape[1] from copy import deepcopy from deepgp.encoder.mlp import MLP self.encoder = MLP([dim_in, int((dim_in+dim_out)*2./3.), int((dim_in+dim_out)/3.), dim_out] if encoder_dims is None \ else [dim_in]+deepcopy(encoder_dims)+[dim_out]) else: raise Exception('Unsupported encoder type: ' + encoder) self.Y_var_common = Param('Y_var', self.Y.variance.values[1].copy(), Logexp()) # Synchronize across MPI nodes if self.mpi_comm is not None: from ..util.parallel import broadcastArrays broadcastArrays([self.encoder.param_array, self.Y_var_common], self.mpi_comm, self.mpi_root) self.link_parameters(self.encoder, self.Y_var_common)
def _init_encoder(self, MLP_dims): from .mlp import MLP from copy import deepcopy from GPy.core.parameterization.transformations import Logexp X_win, X_dim, U_win, U_dim = self.X_win, self.X_dim, self.U_win, self.U_dim assert X_win > 0, "Neural Network constraints only applies autoregressive structure!" Q = X_win * X_dim + U_win * U_dim if self.withControl else X_win * X_dim self.init_Xs = [ NormalPosterior(self.Xs_flat[i].mean.values[:X_win], self.Xs_flat[i].variance.values[:X_win], name='init_Xs_' + str(i)) for i in range(self.nSeq) ] for init_X in self.init_Xs: init_X.mean[:] = np.random.randn(*init_X.shape) * 1e-2 self.encoder = MLP([Q, Q * 2, Q + X_dim / 2, X_dim] if MLP_dims is None else [Q] + deepcopy(MLP_dims) + [X_dim]) self.Xs_var = [ Param('X_var_' + str(i), self.Xs_flat[i].variance.values[X_win:].copy(), Logexp()) for i in range(self.nSeq) ]
def __init__(self, Y, dim_down, dim_up, likelihood, MLP_dims=None, X=None, X_variance=None, init='rand', Z=None, num_inducing=10, kernel=None, inference_method=None, uncertain_inputs=True,mpi_comm=None, mpi_root=0, back_constraint=True, name='mrd-view'): self.uncertain_inputs = uncertain_inputs self.layer_lower = None self.scale = 1. if back_constraint: from .mlp import MLP from copy import deepcopy self.encoder = MLP([dim_down, int((dim_down+dim_up)*2./3.), int((dim_down+dim_up)/3.), dim_up] if MLP_dims is None else [dim_down]+deepcopy(MLP_dims)+[dim_up]) X = self.encoder.predict(Y.mean.values if isinstance(Y, VariationalPosterior) else Y) X_variance = 0.0001*np.ones(X.shape) self.back_constraint = True else: self.back_constraint = False if Z is None: Z = np.random.rand(num_inducing, dim_up)*2-1. #np.random.permutation(X.copy())[:num_inducing] assert Z.shape[1] == X.shape[1] if likelihood is None: likelihood = likelihoods.Gaussian(variance=Y.var()*0.01) if uncertain_inputs: X = NormalPosterior(X, X_variance) if kernel is None: kernel = kern.RBF(dim_up, ARD = True) # The command below will also give the field self.X to the view. super(MRDView, self).__init__(X, Y, Z, kernel, likelihood, inference_method=inference_method, mpi_comm=mpi_comm, mpi_root=mpi_root, name=name) if back_constraint: self.link_parameter(self.encoder) if self.uncertain_inputs and self.back_constraint: from GPy import Param from GPy.core.parameterization.transformations import Logexp self.X_var_common = Param('X_var',X_variance[0].copy(),Logexp()) self.link_parameters(self.X_var_common) # There's some redundancy in the self.Xv and self.X. Currently we use self.X for the likelihood part and all calculations part, # self.Xv is only used for the self.Xv.gradient part. # This is redundant but it's there in case we want to do the product of experts MRD model. self.Xv = self.X
def __init__(self, layer_lower, dim_down, dim_up, likelihood, X=None, X_variance=None, init='PCA', Z=None, num_inducing=10, kernel=None, inference_method=None, uncertain_inputs=True,mpi_comm=None, mpi_root=0, back_constraint=True, encoder=None, auto_update=True, name='layer'): self.uncertain_inputs = uncertain_inputs self.layer_lower = layer_lower Y = self.Y if self.layer_lower is None else self.layer_lower.X self.back_constraint = back_constraint from deepgp.util.util import initialize_latent if X is None: X, _ = initialize_latent(init, Y.shape[0], dim_up, Y.mean.values if isinstance(Y, VariationalPosterior) else Y) if X_variance is None: X_variance = 0.01*np.ones(X.shape) + 0.01*np.random.rand(*X.shape) if Z is None: if self.back_constraint: Z = np.random.rand(num_inducing, dim_up)*2-1. else: if num_inducing<=X.shape[0]: Z = X[np.random.permutation(X.shape[0])[:num_inducing]].copy() else: Z_more = np.random.rand(num_inducing-X.shape[0],X.shape[1])*(X.max(0)-X.min(0))+X.min(0) Z = np.vstack([X.copy(),Z_more]) assert Z.shape[1] == X.shape[1] if mpi_comm is not None: from ..util.parallel import broadcastArrays broadcastArrays([Z], mpi_comm, mpi_root) if uncertain_inputs: X = NormalPosterior(X, X_variance) if kernel is None: kernel = kern.RBF(dim_up, ARD = True) assert kernel.input_dim==X.shape[1], "The dimensionality of input has to be equal to the input dimensionality of kernel!" self.Kuu_sigma = Param('Kuu_var', np.zeros(num_inducing)+1e-3, Logexp()) super(Layer, self).__init__(X, Y, Z, kernel, likelihood, inference_method=inference_method, mpi_comm=mpi_comm, mpi_root=mpi_root, auto_update=auto_update, name=name) self.link_parameter(self.Kuu_sigma) if back_constraint: self.encoder = encoder if self.uncertain_inputs and not self.back_constraint: self.link_parameter(self.X)
def __init__(self, k1, k2=None, kc=1., xc=np.array([[0]]), cpDim=0, changepointParameter=False): """ arguments: k1, k2: GPy.kern.Kernel kc: float, covariance at the changepoint xc: np.array, position of changepoint(s) cpDim: int, dimension that changepoint exists on changepointParameter: bool, whether xc should be linked as a parameter """ if k2 is None: super(Changepoint, self).__init__([k1], "changepoint") k2 = k1 else: super(Changepoint, self).__init__([k1, k2], "changepoint") self.k1 = k1 self.k2 = k2 self.kc = Param('kc', kc, Logexp()) self.link_parameter(self.kc) self.changepointParameter = changepointParameter self.xc = np.array(xc) if self.changepointParameter: self.xc = Param('xc', self.xc) self.link_parameter(self.xc) self.xc.gradient = [[0]] self.cpDim = cpDim