def __init__(self, Y=None, X0=None, k=1, standardize=False, interaction=True): """ Y: data [NxG] X0: known latent factors [Nxk0] k: number of latent factors to infer """ assert Y != None, 'gpCLVM:: set Y!' assert X0 != None, 'gpCLVM:: set X0!' self.cache = {} self.interaction = interaction # read data self._setY(Y, standardize=standardize) self._setX0(X0) self.k = k # covariance for known latex factor self.C0 = limix.CFixedCF(self.K0) # covariance for unknow latent factor self.C = limix.CProductCF() self.Ca = limix.CLowRankCF(self.N, self.k) self.C.addCovariance(self.Ca) if self.interaction == True: self.Cb1 = limix.CFixedCF(SP.ones((self.N, self.N))) self.Cb1.setParamMask(SP.zeros(1)) self.Cb2 = limix.CFixedCF(self.K0) self.Cb = limix.CSumCF() self.Cb.addCovariance(self.Cb1) self.Cb.addCovariance(self.Cb2) self.C.addCovariance(self.Cb) # total covariance covar = limix.CSumCF() covar.addCovariance(self.C0) covar.addCovariance(self.C) # likelihood self.ll = limix.CLikNormalIso() # init GP and hyper params self.gp = limix.CGPbase(covar, self.ll) self.gp.setY(self.Y)
def setUp(self): SP.random.seed(1) self.n = 4 self.C = limix.CFixedCF(SP.ones((self.n, self.n))) self.name = 'CFixedCF' self.n_params = self.C.getNumberParams() K = self.C.K() params = SP.exp(SP.randn(self.n_params)) self.C.setParams(params)
def setUp(self): SP.random.seed(1) self.n=10 n_dim2=12 K0 = SP.eye(self.n) self.C=limix.CSumCF() #sum of fixed CF and linearARD covar1 = limix.CFixedCF(K0) covar2 = limix.CCovLinearARD(n_dim2) self.C.addCovariance(covar1) self.C.addCovariance(covar2) self.n_dim=self.C.getNumberDimensions() self.X=SP.rand(self.n,self.n_dim) self.C.setX(self.X) self.name = 'CSumCF' self.n_params=self.C.getNumberParams() params=SP.exp(SP.randn(self.n_params)) self.C.setParams(params)
def setUp(self): SP.random.seed(1) #1. simulate self.settings = {'K': 5, 'N': 100, 'D': 80} self.simulation = self.simulate() N = self.settings['N'] K = self.settings['K'] D = self.settings['D'] #2. setup GP K0 = SP.dot(self.simulation['S'], self.simulation['S'].T) K0[:] = 0 covar1 = limix.CFixedCF(K0) covar2 = limix.CCovLinearISO(K) covar = limix.CSumCF() covar.addCovariance(covar1) covar.addCovariance(covar2) ll = limix.CLikNormalIso() #create hyperparm covar_params = SP.array([0.0, 1.0]) lik_params = SP.array([0.1]) hyperparams = limix.CGPHyperParams() hyperparams['covar'] = covar_params hyperparams['lik'] = lik_params hyperparams['X'] = self.simulation['X0'] #cretae GP self.gp = limix.CGPbase(covar, ll) #set data self.gp.setY(self.simulation['Y']) self.gp.setX(self.simulation['X0']) self.gp.setParams(hyperparams) pass
def _buildTraitCovar(self, trait_covar_type='lowrank_diag', rank=1, fixed_trait_covar=None, jitter=1e-4): """ Internal functions that builds the trait covariance matrix using the LIMIX framework Args: trait_covar_type: type of covaraince to use. Default 'freeform'. possible values are rank: rank of a possible lowrank component (default 1) fixed_trait_covar: PxP matrix for the (predefined) trait-to-trait covariance matrix if fixed type is used jitter: diagonal contribution added to trait-to-trait covariance matrices for regularization Returns: LIMIX::PCovarianceFunction for Trait covariance matrix vector labelling Cholesky parameters for different initializations """ cov = limix.CSumCF() if trait_covar_type == 'freeform': cov.addCovariance(limix.CFreeFormCF(self.P)) L = sp.eye(self.P) diag = sp.concatenate([L[i, :(i + 1)] for i in range(self.P)]) elif trait_covar_type == 'fixed': assert fixed_trait_covar != None, 'VarianceDecomposition:: set fixed_trait_covar' assert fixed_trait_covar.shape[ 0] == self.N, 'VarianceDecomposition:: Incompatible shape for fixed_trait_covar' assert fixed_trait_covar.shape[ 1] == self.N, 'VarianceDecomposition:: Incompatible shape for fixed_trait_covar' cov.addCovariance(limix.CFixedCF(fixed_trait_covar)) diag = sp.zeros(1) elif trait_covar_type == 'diag': cov.addCovariance(limix.CDiagonalCF(self.P)) diag = sp.ones(self.P) elif trait_covar_type == 'lowrank': cov.addCovariance(limix.CLowRankCF(self.P, rank)) diag = sp.zeros(self.P * rank) elif trait_covar_type == 'lowrank_id': cov.addCovariance(limix.CLowRankCF(self.P, rank)) cov.addCovariance(limix.CFixedCF(sp.eye(self.P))) diag = sp.concatenate([sp.zeros(self.P * rank), sp.ones(1)]) elif trait_covar_type == 'lowrank_diag': cov.addCovariance(limix.CLowRankCF(self.P, rank)) cov.addCovariance(limix.CDiagonalCF(self.P)) diag = sp.concatenate([sp.zeros(self.P * rank), sp.ones(self.P)]) elif trait_covar_type == 'block': cov.addCovariance(limix.CFixedCF(sp.ones((self.P, self.P)))) diag = sp.zeros(1) elif trait_covar_type == 'block_id': cov.addCovariance(limix.CFixedCF(sp.ones((self.P, self.P)))) cov.addCovariance(limix.CFixedCF(sp.eye(self.P))) diag = sp.concatenate([sp.zeros(1), sp.ones(1)]) elif trait_covar_type == 'block_diag': cov.addCovariance(limix.CFixedCF(sp.ones((self.P, self.P)))) cov.addCovariance(limix.CDiagonalCF(self.P)) diag = sp.concatenate([sp.zeros(1), sp.ones(self.P)]) else: assert True == False, 'VarianceDecomposition:: trait_covar_type not valid' if jitter > 0: _cov = limix.CFixedCF(sp.eye(self.P)) _cov.setParams(sp.array([sp.sqrt(jitter)])) _cov.setParamMask(sp.zeros(1)) cov.addCovariance(_cov) return cov, diag
Yf += SP.kron([1, 0], ys)[:, SP.newaxis] Iinter.append(iis) Iasso = SP.array(Iasso) Iinter = SP.array(Iinter) #1.7: sum of fixed and random effect Y = Yf + Yr #standardize Y -= Y.mean() Y /= Y.std() #2. fitting using limix GP = {} #fix covariance, taking population structure GP['covar_G'] = limix.CFixedCF(Kpopf) #freeform covariance: requiring number of traits/group (T) GP['covar_E'] = limix.CCovFreeform(T) #overall covarianc: product GP['covar'] = limix.CProductCF() GP['covar'].addCovariance(GP['covar_G']) GP['covar'].addCovariance(GP['covar_E']) #liklihood: gaussian GP['ll'] = limix.CLikNormalIso() GP['data'] = limix.CData() GP['hyperparams'] = limix.CGPHyperParams() #Create GP instance GP['gp'] = limix.CGPbase(GP['data'], GP['covar'], GP['ll']) #set data
def train(self,rank=20,Kpop=True,LinearARD=False): """train panama module""" if 0: covar = limix.CCovLinearISO(rank) ll = limix.CLikNormalIso() X0 = sp.random.randn(self.N,rank) X0 = PCA(self.Y,rank)[0] X0 /= sp.sqrt(rank) covar_params = sp.array([1.0]) lik_params = sp.array([1.0]) hyperparams = limix.CGPHyperParams() hyperparams['covar'] = covar_params hyperparams['lik'] = lik_params hyperparams['X'] = X0 constrainU = limix.CGPHyperParams() constrainL = limix.CGPHyperParams() constrainU['covar'] = +5*sp.ones_like(covar_params); constrainL['covar'] = 0*sp.ones_like(covar_params); constrainU['lik'] = +5*sp.ones_like(lik_params); constrainL['lik'] = 0*sp.ones_like(lik_params); if 1: covar = limix.CSumCF() if LinearARD: covar_1 = limix.CCovLinearARD(rank) covar_params = [] for d in range(rank): covar_params.append(1/sp.sqrt(d+2)) else: covar_1 = limix.CCovLinearISO(rank) covar_params = [1.0] covar.addCovariance(covar_1) if self.use_Kpop: covar_2 = limix.CFixedCF(self.Kpop) covar.addCovariance(covar_2) covar_params.append(1.0) ll = limix.CLikNormalIso() X0 = PCA(self.Y,rank)[0] X0 /= sp.sqrt(rank) covar_params = sp.array(covar_params) lik_params = sp.array([1.0]) hyperparams = limix.CGPHyperParams() hyperparams['covar'] = covar_params hyperparams['lik'] = lik_params hyperparams['X'] = X0 constrainU = limix.CGPHyperParams() constrainL = limix.CGPHyperParams() constrainU['covar'] = +5*sp.ones_like(covar_params); constrainL['covar'] = -5*sp.ones_like(covar_params); constrainU['lik'] = +5*sp.ones_like(lik_params); gp=limix.CGPbase(covar,ll) gp.setY(self.Y) gp.setX(X0) lml0 = gp.LML(hyperparams) dlml0 = gp.LMLgrad(hyperparams) gpopt = limix.CGPopt(gp) gpopt.setOptBoundLower(constrainL); gpopt.setOptBoundUpper(constrainU); t1 = time.time() gpopt.opt() t2 = time.time() #Kpanama self.Xpanama = covar_1.getX() if LinearARD: self.Xpanama /= self.Xpanama.std(0) self.Kpanama = covar_1.K() self.Kpanama/= self.Kpanama.diagonal().mean() # Ktot self.Ktot = covar_1.K() if self.use_Kpop: self.Ktot += covar_2.K() self.Ktot/= self.Ktot.diagonal().mean() #store variances V = {} if LinearARD: V['LinearARD'] = covar_1.getParams()**2*covar_1.getX().var(0) else: V['Kpanama'] = sp.array([covar_1.K().diagonal().mean()]) if self.use_Kpop: V['Kpop'] = sp.array([covar_2.K().diagonal().mean()]) V['noise'] = gp.getParams()['lik']**2 self.varianceComps = V
if 1: N = 100 D = 20 NS = 100 SP.random.seed(1) ir = SP.random.permutation(NS)[0] S = SP.random.randn(N, NS) W = SP.random.randn(1, D) Y = SP.dot(S[:, ir:ir + 1], W) Y += 0.1 * SP.random.randn(N, D) if 1: covar_c = limix.CFixedCF(SP.eye(D)) covar_r = limix.CFixedCF(SP.eye(N)) Xr = SP.zeros([N, 0]) Xc = SP.zeros([D, 0]) gp = limix.CGPkronecker(covar_r, covar_c) gp.setX_r(Xr) gp.setX_c(Xc) gp.setY(Y) params = limix.CGPHyperParams() params["covar_r"] = SP.zeros([covar_r.getNumberParams()]) params["covar_c"] = SP.zeros([covar_c.getNumberParams()]) params["lik"] = SP.log([0.1, 0.1]) gp.setParams(params)
def addMultiTraitTerm(self, K=None, covar_type='freeform', is_noise=False, normalize=True, Ks=None, offset=1e-4, rank=1, covar_K0=None): """ add multi trait random effects term. The inter-trait covariance is parametrized by covar_type, where parameters are optimized. Args: K: Individual-individual (Intra-Trait) Covariance Matrix [N, N] (K is normalised in the C++ code such that K.trace()=N) covar_type: type of covaraince to use. Default 'freeform'. possible values are 'freeform': free form optimization, 'fixed': use a fixed matrix specified in covar_K0, 'diag': optimize a diagonal matrix, 'lowrank': optimize a low rank matrix. The rank of the lowrank part is specified in the variable rank, 'lowrank_id': optimize a low rank matrix plus the weight of a constant diagonal matrix. The rank of the lowrank part is specified in the variable rank, 'lowrank_diag': optimize a low rank matrix plus a free diagonal matrix. The rank of the lowrank part is specified in the variable rank, 'block': optimize the weight of a constant P x P block matrix of ones, 'block_id': optimize the weight of a constant P x P block matrix of ones plus the weight of a constant diagonal matrix, 'block_diag': optimize the weight of a constant P x P block matrix of ones plus a free diagonal matrix, is_noise: Boolean indicator specifying if the matrix is homoscedastic noise (weighted identity covariance) (default False) normalize: Boolean indicator specifying if K is normalized such that K.trace()=N. Ks: NxNtest cross covariance for predictions offset: diagonal contribution added to trait-to-trait covariance matrices for regularization rank: rank of a possible lowrank component (default 1) covar_K0: PxP matrix for the (predefined) trait-to-trait covariance matrix if fixed type is used """ assert self.P > 1, 'CVarianceDecomposition:: Incompatible number of traits' assert K != None or is_noise, 'CVarianceDecomposition:: Specify covariance structure' assert offset >= 0, 'CVarianceDecomposition:: offset must be >=0' #TODO: check that covar_K0 is correct if fixed typeCF is used.. if is_noise: assert self.noisPos == None, 'CVarianceDecomposition:: noise term already exists' K = SP.eye(self.N) self.noisPos = self.n_terms else: assert K.shape[ 0] == self.N, 'CVarianceDecomposition:: Incompatible shape' assert K.shape[ 1] == self.N, 'CVarianceDecomposition:: Incompatible shape' if Ks != None: assert Ks.shape[ 0] == self.N, 'CVarianceDecomposition:: Incompatible shape' if normalize: Norm = 1 / K.diagonal().mean() K *= Norm if Ks != None: Ks *= Norm cov = limix.CSumCF() if covar_type == 'freeform': cov.addCovariance(limix.CFreeFormCF(self.P)) L = SP.eye(self.P) diag = SP.concatenate([L[i, :(i + 1)] for i in range(self.P)]) elif covar_type == 'fixed': cov.addCovariance(limix.CFixedCF(covar_K0)) diag = SP.zeros(1) elif covar_type == 'diag': cov.addCovariance(limix.CDiagonalCF(self.P)) diag = SP.ones(self.P) elif covar_type == 'lowrank': cov.addCovariance(limix.CLowRankCF(self.P, rank)) diag = SP.zeros(self.P * rank) elif covar_type == 'lowrank_id': cov.addCovariance(limix.CLowRankCF(self.P, rank)) cov.addCovariance(limix.CFixedCF(SP.eye(self.P))) diag = SP.concatenate([SP.zeros(self.P * rank), SP.ones(1)]) elif covar_type == 'lowrank_diag': cov.addCovariance(limix.CLowRankCF(self.P, rank)) cov.addCovariance(limix.CDiagonalCF(self.P)) diag = SP.concatenate([SP.zeros(self.P * rank), SP.ones(self.P)]) elif covar_type == 'block': cov.addCovariance(limix.CFixedCF(SP.ones((self.P, self.P)))) diag = SP.zeros(1) elif covar_type == 'block_id': cov.addCovariance(limix.CFixedCF(SP.ones((self.P, self.P)))) cov.addCovariance(limix.CFixedCF(SP.eye(self.P))) diag = SP.concatenate([SP.zeros(1), SP.ones(1)]) elif covar_type == 'block_diag': cov.addCovariance(limix.CFixedCF(SP.ones((self.P, self.P)))) cov.addCovariance(limix.CDiagonalCF(self.P)) diag = SP.concatenate([SP.zeros(1), SP.ones(self.P)]) else: assert True == False, 'CVarianceDecomposition:: covar_type not valid' if offset > 0: _cov = limix.CFixedCF(SP.eye(self.P)) _cov.setParams(SP.array([SP.sqrt(offset)])) _cov.setParamMask(SP.zeros(1)) cov.addCovariance(_cov) self.offset.append(offset) self.covar_type.append(covar_type) self.diag.append(diag) self.vd.addTerm(cov, K) if Ks != None: self.setKstar(self.n_terms, Ks) self.n_terms += 1 self.gp = None self.init = False self.fast = False self.optimum = None self.cache['Sigma'] = None self.cache['Hessian'] = None self.cache['Lparams'] = None self.cache['paramsST'] = None
P = D['Y'].shape[1] Y = D['Y'] X = D['X'] Y = Y[0:10] X = X[0:10] N = Y.shape[0] Kg = SP.dot(X, X.T) Kg = Kg / Kg.diagonal().mean() K0 = SP.eye(Y.shape[0]) X0 = SP.randn(Y.shape[0], 3) covar1 = limix.CCovLinearISO(3) covar1.setParams(SP.array([1.0])) covar1.setX(X0) covar2 = limix.CFixedCF(K0) covar2.setParams(SP.array([1.0])) covar = limix.CSumCF() covar.addCovariance(covar2) covar.addCovariance(covar1) ll = limix.CLikNormalIso() gp = limix.CGPbase(covar, ll) hyperparams = limix.CGPHyperParams() hyperparams['covar'] = SP.array([1.0, 1.0]) hyperparams['lik'] = SP.array([0.1]) hyperparams['X'] = X0 gp.setY(Y)
# NON-COMPATIBLE PARAM BOUNDS # 1. Wrong number of components LB=SP.array([0.]) UB=float('inf')*SP.ones(2) C.setParamBounds(LB,UB) # 2. Upper < Lower LB=+1.*SP.ones(2) UB=-1.*SP.ones(2) C.setParamBounds(LB,UB) """ LB = SP.array([0., 5.]) UB = SP.array([float('inf'), 10.]) C.setParamBounds(LB, UB) print C.getParamBounds0() print C.getParamBounds() # MULTI COVARIANCE C1 = limix.CFixedCF() C2 = limix.CCovSqexpARD(1) CP = limix.CProductCF() CP.addCovariance(C1) CP.addCovariance(C2) CP.setParamBounds(5 * SP.ones(3), 10 * SP.ones(3)) print CP.getParamBounds0() print CP.getParamBounds() # ALSO DEFINED IN LIKELIHOODS L = limix.CLikNormalIso() L.setParamBounds(SP.array([0]), SP.array([10])) L.getParamBounds()
# Dimensions N = (T == 0).sum() P = int(T.max() + 1) # Transform Geno and Pheno X = SP.array(X[0:N, :], dtype=float) Y = Y.reshape(P, N).T Y = SP.stats.zscore(Y, 0) # Set Kronecker matrices K = SP.dot(X, X.T) K = K / K.diagonal().mean() print "GP KRONECKER SUM" # Covariances covarc1 = limix.CFreeFormCF(P) covarc2 = limix.CFreeFormCF(P) covarr1 = limix.CFixedCF(K) covarr2 = limix.CFixedCF(SP.eye(N)) covarr1.setParamMask(SP.zeros(1)) covarr2.setParamMask(SP.zeros(1)) # CLinearMean F1 = SP.ones((N, 1)) W1 = SP.zeros((1, P)) A1 = SP.eye(P) mean1 = limix.CKroneckerMean() mean1.setA(A1) mean1.setFixedEffects(F1) mean1.setParams(W1) F2 = SP.randn(N, 1) W2 = SP.zeros((1, 1)) A2 = SP.ones((1, P)) mean2 = limix.CKroneckerMean()