def setUp(self):
SP.random.seed(1)
self.n_dimensions = 2
self.n_samples = 100
self.setXy()
#self.X = SP.rand(self.n_samples,self.n_dimensions)
covar = limix.CCovSqexpARD(self.n_dimensions)
ll = limix.CLikNormalIso()
covar_params = SP.array([1, 1, 1])
lik_params = SP.array([0.5])
hyperparams0 = limix.CGPHyperParams()
hyperparams0['covar'] = covar_params
hyperparams0['lik'] = lik_params
self.constrainU = limix.CGPHyperParams()
self.constrainL = limix.CGPHyperParams()
self.constrainU['covar'] = +10 * SP.ones_like(covar_params)
self.constrainL['covar'] = 0 * SP.ones_like(covar_params)
self.constrainU['lik'] = +5 * SP.ones_like(lik_params)
self.constrainL['lik'] = 0 * SP.ones_like(lik_params)
self.gp = limix.CGPbase(covar, ll)
self.gp.setX(self.X)
self.gp.setParams(hyperparams0)
#self.genY()
self.gp.setY(self.y)
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
covar = limix.CCovLinearISO(K)
ll = limix.CLikNormalIso()
#create hyperparm
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'] = 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 _initParams_fast(self): """ initialize the gp parameters 1) project Y on the known factor X0 -> Y0 average variance of Y0 is used to initialize the variance explained by X0 2) considers the residual Y1 = Y-Y0 (this equivals to regress out X0) 3) perform PCA on cov(Y1) and considers the first k PC for initializing X 4) the variance of all other PCs is used to initialize the noise 5) the variance explained by interaction is set to a small random number """ Xd = LA.pinv(self.X0) Y0 = self.X0.dot(Xd.dot(self.Y)) Y1 = self.Y-Y0 YY = SP.cov(Y1) S,U = LA.eigh(YY) X = U[:,-self.k:]*SP.sqrt(S[-self.k:]) a = SP.array([SP.sqrt(Y0.var(0).mean())]) b = 1e-3*SP.randn(1) c = SP.array([SP.sqrt((YY-SP.dot(X,X.T)).diagonal().mean())]) # gp hyper params params = limix.CGPHyperParams() if self.interaction: params['covar'] = SP.concatenate([a,X.reshape(self.N*self.k,order='F'),SP.ones(1),b]) else: params['covar'] = SP.concatenate([a,X.reshape(self.N*self.k,order='F')]) params['lik'] = c return params
def _initParams_regressOut(self, Ycc, X, varXX):
"""
initialize the gp parameters
1) the variance of Kcc as Ycc.var(0).mean()
2) X with the provided
3) variance of interaction (if label is True) will be set to ~0
4) residual to residual
"""
X *= SP.sqrt(varXX / (X**2).mean())
Y1 = self.Y - Ycc
a = SP.array([SP.sqrt(Ycc.var(0).mean())])
b = 1e-3 * SP.ones(1)
c = Y1.var(0).mean() - varXX
c = SP.maximum(1e-1, c)
c = SP.array([SP.sqrt(c)])
# gp hyper params
params = limix.CGPHyperParams()
if self.interaction:
params['covar'] = SP.concatenate(
[a, X.reshape(self.N * self.k, order='F'),
SP.ones(1), b])
else:
params['covar'] = SP.concatenate(
[a, X.reshape(self.N * self.k, order='F')])
params['lik'] = c
return params
def _initParams_random(self): """ initialize the gp parameters randomly """ # gp hyper params params = limix.CGPHyperParams() if self.interaction: params['covar'] = SP.concatenate([SP.randn(self.N*self.k+1),SP.ones(1),SP.randn(1)]) else: params['covar'] = SP.randn(self.N*self.k+1) params['lik'] = SP.randn(1) return params
def _initParams_null(self,varX0X0,nois): """ initialize from null model """ X = 1e-3*SP.randn(self.N,self.k) a = SP.array([SP.sqrt(varX0X0)]) b = 1e-3*SP.ones(1) c = SP.array([SP.sqrt(nois)]) # gp hyper params params = limix.CGPHyperParams() if self.interaction: params['covar'] = SP.concatenate([a,X.reshape(self.N*self.k,order='F'),SP.ones(1),b]) else: params['covar'] = SP.concatenate([a,X.reshape(self.N*self.k,order='F')]) params['lik'] = c return 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
#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
GP['gp'].setY(Y)
#input: effectively we require the group for each sample (CCovFreeform requires this)
Xtrain = SP.zeros([Y.shape[0], 1])
Xtrain[N::1] = 1
GP['gp'].setX(Xtrain)
gpopt = limix.CGPopt(GP['gp'])
#constraints: make sure that noise level does not go completel crazy
constrainU = limix.CGPHyperParams()
constrainL = limix.CGPHyperParams()
constrainU['lik'] = +5 * SP.ones([1])
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
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)
opt = limix.CGPopt(gp)
opt.opt()
#opt.gradCheck()
if 0:
opt_params = limix.CGPHyperParams()
opt_params["lik"] = params["lik"]
gp.setParams(opt_params)
pdb.set_trace()
#GPMIX:
cov = SP.ones([y.shape[0], 2])
cov[:, 1] = SP.randn(cov.shape[0])
covar = limix.CCovSqexpARD(n_dimensions)
ll = limix.CLikNormalIso()
if 1:
data = limix.CLinearMean(y, cov)
data_params = SP.ones([cov.shape[1]])
else:
data = limix.CData()
data_params = None
#create hyperparm
hyperparams = limix.CGPHyperParams()
hyperparams['covar'] = covar_params
hyperparams['lik'] = lik_params
if data_params is not None:
hyperparams['dataTerm'] = data_params
#cretae GP
gp = limix.CGPbase(covar, ll, data)
#set data
gp.setY(y)
gp.setX(X)
gp.setParams(hyperparams)
lml = gp.LML()
dlml = gp.LMLgrad()
#build constraints
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)
gp.setX(X0)
gp.setParams(hyperparams)
F2 = SP.randn(N, 1)
W2 = SP.zeros((1, 1))
A2 = SP.ones((1, P))
mean2 = limix.CKroneckerMean()
mean2.setA(A2)
mean2.setFixedEffects(F2)
mean2.setParams(W2)
mean = limix.CSumLinear()
mean.appendTerm(mean1)
mean.appendTerm(mean2)
mean.aGetParams()
# GPkronSum
gpKS = limix.CGPkronSum(Y, covarr1, covarc1, covarr2, covarc2,
limix.CLikNormalNULL(), mean)
# initalization
params = limix.CGPHyperParams()
params['covarc1'] = SP.randn(covarc1.getNumberParams())
params['covarc2'] = SP.randn(covarc2.getNumberParams())
params['covarr1'] = SP.ones(1)
params['covarr2'] = SP.ones(1)
params['dataTerm'] = SP.randn(P + 1, 1)
gpKS.setParams(params)
# Paramask
paramMask = limix.CGPHyperParams()
paramMask['covarc1'] = covarc1.getParamMask()
paramMask['covarc2'] = covarc2.getParamMask()
paramMask['covarr1'] = covarr1.getParamMask()
paramMask['covarr2'] = covarr2.getParamMask()
# optimisation
gpKSopt = limix.CGPopt(gpKS)
start_time = time.time()
pdb.set_trace()
#initialize LIMX objet
#1. determine covariance function:
# Squared expontential, Gaussian kernel
covar = limix.CCovSqexpARD(n_dimensions)
#2. likelihood: Gaussian noise
ll = limix.CLikNormalIso()
#startin parmaeters are set random
covar_params = SP.array([1, 0.2])
lik_params = SP.array([0.01])
#create hyperparameter object
hyperparams0 = limix.CGPHyperParams()
#set fields "covar" and "lik"
hyperparams0['covar'] = covar_params
hyperparams0['lik'] = lik_params
#cretae GP object
gp = limix.CGPbase(covar, ll)
#inputs
gp.setX(X)
#startgin parameters
gp.setParams(hyperparams0)
#generate and set outputs
y = SP.random.multivariate_normal(SP.zeros(X.shape[0]),
(gp.getCovar()).K() + (gp.getLik()).K())
gp.setY(y)
