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()
