def test_interval(self, M0, M1, verbose=False, opt=None, Ngibbs_iterations=10):
"""test with interval sampling test
M0: first expresison condition
M1: second condition
verbose: produce plots (False)
opt: optimise hyperparameters(True)
Ngibbs_iterations (10)
"""
def rescaleInputs(X, gpr):
"""copy implementation of input rescaling
- this version rescales in a dum way assuming everything is float
"""
X_ = (X - gpr.minX) * gpr.scaleX - 5
return X_
def sampleIndicator(I, take_out=True):
"""sample all indicators that are true in the index vector I
take_out: take indices out of the dataset first (yes)
"""
PZ = S.zeros([2, I.sum()])
if take_out:
IS_ = IS & (~I)
IJ_ = IJ & (~I)
else:
IS_ = IS
IJ_ = IJ
# set datasets
self.gpr_0.setData(
S.concatenate((M0R[0][:, IS_]), axis=0).reshape([-1, 1]),
S.concatenate((M0R[1][:, IS_]), axis=1),
process=False,
)
self.gpr_1.setData(
S.concatenate((M1R[0][:, IS_]), axis=0).reshape([-1, 1]),
S.concatenate((M1R[1][:, IS_]), axis=1),
process=False,
)
self.gpr_join.setData(
S.concatenate((MJR[0][:, IJ_]), axis=0).reshape([-1, 1]),
S.concatenate((MJR[1][:, IJ_]), axis=1),
process=False,
)
Yp0 = self.gpr_0.predict(self.gpr_0.logtheta, XT[I], mean=False)
Yp1 = self.gpr_1.predict(self.gpr_0.logtheta, XT[I], mean=False)
Ypj = self.gpr_join.predict(self.gpr_0.logtheta, XT[I], mean=False)
# compare to hypothesis
# calculate log likelihoods for every time step under different models
# D0 = -0.5*(M0R[1][:,I]-Yp0[0])**2/Yp0[1] -0.5*S.log(Yp0[1])
# D1 = -0.5*(M1R[1][:,I]-Yp1[0])**2/Yp1[1] -0.5*S.log(Yp1[1])
# DJ = -0.5*(MJR[1][:,I]-Ypj[0])**2/Ypj[1] -0.5*S.log(Ypj[1])
# robust likelihood
c = 0.9
D0 = c * S.exp(-0.5 * (M0R[1][:, I] - Yp0[0]) ** 2 / Yp0[1]) * 1 / sqrt(2 * S.pi * Yp0[1])
D0 += (1 - c) * S.exp(-0.5 * (M0R[1][:, I] - Yp0[0]) ** 2 / 1e8) * 1 / sqrt(2 * pi * S.sqrt(1e8))
D0 = S.log(D0)
D1 = c * S.exp(-0.5 * (M1R[1][:, I] - Yp1[0]) ** 2 / Yp1[1]) * 1 / sqrt(2 * S.pi * Yp1[1])
D1 += (1 - c) * S.exp(-0.5 * (M1R[1][:, I] - Yp1[0]) ** 2 / 1e8) * 1 / sqrt(2 * pi * S.sqrt(1e8))
D1 = S.log(D1)
DJ = c * S.exp(-0.5 * (MJR[1][:, I] - Ypj[0]) ** 2 / Ypj[1]) * 1 / sqrt(2 * S.pi * Ypj[1])
DJ += (1 - c) * S.exp(-0.5 * (MJR[1][:, I] - Ypj[0]) ** 2 / 1e8) * 1 / sqrt(2 * pi * S.sqrt(1e8))
DJ = S.log(DJ)
DS = D0.sum(axis=0) + D1.sum(axis=0)
DJ = DJ.sum(axis=0)
ES = S.exp(DS)
EJ = S.exp(DJ)
PZ[0, :] = self.prior_Z[0] * EJ
PZ[1, :] = self.prior_Z[1] * ES
PZ /= PZ.sum(axis=0)
# sample indicators
Z = S.rand(I.sum()) <= PZ[1, :]
if IS_.sum() == 1:
Z = True
if IJ_.sum() == 1:
Z = False
return [Z, PZ]
pass
pass
# 1. use the standard method to initialise the GP objects
ratio = self.test(M0, M1, verbose=verbose, opt=opt)
GP0 = CP.deepcopy(self.gpr_0)
GP1 = CP.deepcopy(self.gpr_1)
GPJ = CP.deepcopy(self.gpr_join)
# 2. initialise gibbs samplign for time-local approximation
# get set of unique time coordinates
XT = M0[0][0].reshape([-1, 1])
# rescale all datasets inputs
MJ = [S.concatenate((M0[0], M1[0]), axis=0), S.concatenate((M0[1], M1[1]), axis=0)]
MJR = CP.deepcopy(MJ)
M0R = CP.deepcopy(M0)
M1R = CP.deepcopy(M1)
# rescale and 0 mean
MJR[0] = rescaleInputs(MJ[0], self.gpr_join)
M0R[0] = rescaleInputs(M0[0], self.gpr_0)
M1R[0] = rescaleInputs(M1[0], self.gpr_1)
MJR[1] -= self.gpr_join.mean
M0R[1] -= self.gpr_0.mean
M1R[1] -= self.gpr_1.mean
# index vector assigning each time point to either expert
IS = S.ones([XT.shape[0]], dtype="bool")
IJ = S.ones([XT.shape[0]], dtype="bool")
# 1. sample all indicators conditioned on current GP approximation
Z_ = sampleIndicator(S.ones(XT.shape[0], dtype="bool"), take_out=False)
Z_ = S.random.rand(IS.shape[0]) > 0.5
PZ = S.zeros([2, IS.shape[0]])
Z = S.zeros([Ngibbs_iterations, IS.shape[0]], dtype="bool")
# update the datasets in the GP, attention: rescaling might cause trouble here..
IS[~Z_] = False
IJ[Z_] = False
# sample indicators one by one
for n in range(Ngibbs_iterations):
# for i in random.permutation(IS.shape[0]):
for i in S.arange(IS.shape[0]):
# resample a single indicator
I = S.zeros([IS.shape[0]], dtype="bool")
I[i] = True
[Z_, PZ_] = sampleIndicator(I)
# save prob. and indicator value
PZ[:, i] = S.squeeze(PZ_)
Z[n, i] = S.squeeze(Z_)
# update indicators
IS[i] = Z_
IJ[i] = ~Z_
LG.debug("Gibbs iteration:%d" % (n))
LG.debug(PZ)
LG.debug(IS)
n_ = round(Ngibbs_iterations) / 2
Z = Z[n_::]
PZ[1, :] = Z.mean(axis=0)
PZ[0, :] = 1 - PZ[1, :]
GP0 = self.gpr_0
GP1 = self.gpr_1
GPJ = self.gpr_join
if verbose:
PL.clf()
# 1. plot the gp predictions
ax1 = PL.axes([0.1, 0.1, 0.8, 0.7])
Xt_ = S.linspace(0, XT[:, 0].max() + 2, 100)
Xt = Xt_.reshape([-1, 1])
self.plotGPpredict(GP0, M0, Xt, {"alpha": 0.1, "facecolor": "r"}, {"linewidth": 2, "color": "r"})
self.plotGPpredict(GP1, M0, Xt, {"alpha": 0.1, "facecolor": "g"}, {"linewidth": 2, "color": "g"})
self.plotGPpredict(GPJ, M0, Xt, {"alpha": 0.1, "facecolor": "k"}, {"linewidth": 2, "color": "k"})
PL.plot(M0[0].T, M0[1].T, "r.--")
PL.plot(M1[0].T, M1[1].T, "g.--")
PL.xlim([Xt.min(), Xt.max()])
# remove last ytick to avoid overlap
yticks = ax1.get_yticks()[0:-2]
ax1.set_yticks(yticks)
xlabel("Time/h")
ylabel("Log expression level")
Ymax = MJ[1].max()
Ymin = MJ[1].min()
DY = Ymax - Ymin
PL.ylim([Ymin - 0.1 * DY, Ymax + 0.1 * DY])
# now plot hinton diagram with responsibilities on top
ax2 = PL.axes([0.1, 0.715, 0.8, 0.2], sharex=ax1)
# ax2=PL.axes([0.1,0.7,0.8,0.2])
# PL.plot(XT[:,0],Z[1,:])
# swap the order of Z for optical purposes
Z_ = S.ones_like(PZ)
Z_[1, :] = PZ[0, :]
Z_[0, :] = PZ[1, :]
hinton(Z_, X=M0[0][0])
ylabel("diff.")
# hide axis labels
setp(ax2.get_xticklabels(), visible=False)
# font size
# setp( ax1.get_xticklabels(), fontsize=tickSize)
# setp( ax1.get_yticklabels(), fontsize=tickSize)
# setp( ax2.get_xticklabels(), fontsize=tickSize)
# PL.ylim(Ymin-0.1*DY,Ymax+0.1*DY)
return [ratio, PZ]
pass
def test_interval(self,M0,M1,verbose=True,opt=None,Ngibbs_iterations=None):
"""test for differential expression with clustering model
- returns a data structure which reflects the time of sepataoin (posterior over Z)
"""
def updateGP():
"""update the GP datasets and re-evaluate the Ep approximate likelihood"""
#0. update the noise level in accordance with the responsibilities
for t in range(T):
XS[:,t:R*T:T,-1] = 1/(Z[1,t]+1E-6)
XJ[:,t:R*T:T,-1] = 1/(Z[0,t]+1E-6)
GPS.setData(XS,Y)
#here we joint the two conditions
GPJ.setData(S.concatenate(XJ,axis=0),S.concatenate(Y,axis=0))
#1. set the data to both processes
MJ = [S.concatenate((M0[0],M1[0]),axis=0),S.concatenate((M0[1],M1[1]),axis=0)]
C = 2 #conditions
R = M0[0].shape[0] #repl.
T = M0[0].shape[1] #time
D = 2 #dim.
#Responsibilities: components(2) x time
Z = 0.5*S.ones((2,T))
#Data(X/Y): conditions x replicates x time x 2D
X = S.zeros((C,R*T,D))
Y = S.zeros((C,R*T))
#unique times
XT = S.ones((T,2))
XT[:,0] = M0[0][0,:]
[x0,y0] = self.M2GPxy(M0)
[x1,y1] = self.M2GPxy(M1)
X[0,:,0:2] = x0
X[1,:,0:2] = x1
Y[0,:] = y0
Y[1,:] = y1
#create indicator vector to identify unique time points
#create one copy of the input per process as this is used for input dependen noise
XS = X.copy()
XJ = X.copy()
#get hyperparameters form standard test:
ratio = self.test(M0,M1,verbose=False,opt=opt)
logtheta_s = self.gpr_0.logtheta
logtheta_j = self.gpr_join.logtheta
#initialize the two GPs
if self.logtheta0 is None:
logtheta = self.covar.getDefaultParams()
#the two indv. GPs
GP0 = GPR.GP(self.covar,Smean=self.Smean,logtheta=logtheta_s)
GP1 = GPR.GP(self.covar,Smean=self.Smean,logtheta=logtheta_s)
#the group GP summarising the two indiv. processes
GPS = GPR.GroupGP([GP0,GP1])
#the joint process
GPJ = GPR.GP(self.covar,Smean=self.Smean,logtheta=logtheta_j)
#update the GP
updateGP()
debug_plot = True
for i in range(1):
###iterations###
#1. get predictive distribution for both GPs
##debug
#introduce the additional dimension to accom. the per obs. noise model
#get prediction for all time points
Yp0 = GP0.predict(GP0.logtheta,XT)
Yp1 = GP1.predict(GP1.logtheta,XT)
Ypj = GPJ.predict(GPJ.logtheta,XT)
#considere residuals
D0 = ((M0[1]-Yp0[0])**2 * (1/Yp0[1])).sum(axis=0)
D1 = ((M1[1]-Yp1[0])**2 * (1/Yp1[1])).sum(axis=0)
DJ = ((MJ[1]-Ypj[0])**2 * (1/Ypj[1])).sum(axis=0)
#the indiv. GP is the sum
DS = D0+D1
#now use this to restimate Q(Z)
ES = S.exp(-DS)
EJ = S.exp(-DJ)
#
Z[0,:] =self.prior_Z[0]*EJ
Z[1,:] =self.prior_Z[1]*ES
Z /=Z.sum(axis=0)
# pydb.set_trace()
updateGP()
if verbose:
PL.clf()
labelSize = 15
tickSize = 12
#1. plot the gp predictions
ax1=PL.axes([0.1,0.1,0.8,0.7])
Xt_ = S.linspace(0,XT[:,0].max()+2,100)
Xt = S.ones((Xt_.shape[0],2))
Xt[:,0] = Xt_
self.plotGPpredict(GP0,M0,Xt,{'alpha':0.1,'facecolor':'r'},{'linewidth':2,'color':'r'})
self.plotGPpredict(GP1,M0,Xt,{'alpha':0.1,'facecolor':'g'},{'linewidth':2,'color':'g'})
self.plotGPpredict(GPJ,M0,Xt,{'alpha':0.1,'facecolor':'b'},{'linewidth':2,'color':'b'})
PL.plot(M0[0].T,M0[1].T,'r.--')
PL.plot(M1[0].T,M1[1].T,'g.--')
PL.xlim([Xt.min(),Xt.max()])
#remove last ytick to avoid overlap
yticks = ax1.get_yticks()[0:-2]
ax1.set_yticks(yticks)
xlabel('Time/h',size=labelSize)
ylabel('Log expression level',size=labelSize)
#now plot hinton diagram with responsibilities on top
ax2=PL.axes([0.1,0.715,0.8,0.2],sharex=ax1)
# ax2=PL.axes([0.1,0.7,0.8,0.2])
#PL.plot(XT[:,0],Z[1,:])
#swap the order of Z for optical purposes
Z_= S.ones_like(Z)
Z_[1,:] = Z[0,:]
Z_[0,:] = Z[1,:]
hinton(Z_,X=M0[0][0])
ylabel('diff.')
#hide axis labels
setp( ax2.get_xticklabels(), visible=False)
#font size
setp( ax1.get_xticklabels(), fontsize=tickSize)
setp( ax1.get_yticklabels(), fontsize=tickSize)
setp( ax2.get_xticklabels(), fontsize=tickSize)
#axes label
return Z
pass
def test_interval(self,
M0,
M1,
verbose=False,
opt=None,
Ngibbs_iterations=10):
"""test with interval sampling test
M0: first expresison condition
M1: second condition
verbose: produce plots (False)
opt: optimise hyperparameters(True)
Ngibbs_iterations (10)
"""
def rescaleInputs(X, gpr):
"""copy implementation of input rescaling
- this version rescales in a dum way assuming everything is float
"""
X_ = (X - gpr.minX) * gpr.scaleX - 5
return X_
def sampleIndicator(I, take_out=True):
"""sample all indicators that are true in the index vector I
take_out: take indices out of the dataset first (yes)
"""
PZ = S.zeros([2, I.sum()])
if take_out:
IS_ = IS & (~I)
IJ_ = IJ & (~I)
else:
IS_ = IS
IJ_ = IJ
#set datasets
self.gpr_0.setData(S.concatenate((M0R[0][:, IS_]),
axis=0).reshape([-1, 1]),
S.concatenate((M0R[1][:, IS_]), axis=1),
process=False)
self.gpr_1.setData(S.concatenate((M1R[0][:, IS_]),
axis=0).reshape([-1, 1]),
S.concatenate((M1R[1][:, IS_]), axis=1),
process=False)
self.gpr_join.setData(S.concatenate((MJR[0][:, IJ_]),
axis=0).reshape([-1, 1]),
S.concatenate((MJR[1][:, IJ_]), axis=1),
process=False)
Yp0 = self.gpr_0.predict(self.gpr_0.logtheta, XT[I], mean=False)
Yp1 = self.gpr_1.predict(self.gpr_0.logtheta, XT[I], mean=False)
Ypj = self.gpr_join.predict(self.gpr_0.logtheta, XT[I], mean=False)
#compare to hypothesis
#calculate log likelihoods for every time step under different models
#D0 = -0.5*(M0R[1][:,I]-Yp0[0])**2/Yp0[1] -0.5*S.log(Yp0[1])
#D1 = -0.5*(M1R[1][:,I]-Yp1[0])**2/Yp1[1] -0.5*S.log(Yp1[1])
#DJ = -0.5*(MJR[1][:,I]-Ypj[0])**2/Ypj[1] -0.5*S.log(Ypj[1])
#robust likelihood
c = 0.9
D0 = c * S.exp(-0.5 * (M0R[1][:, I] - Yp0[0])**2 /
Yp0[1]) * 1 / sqrt(2 * S.pi * Yp0[1])
D0 += (1 - c) * S.exp(-0.5 * (M0R[1][:, I] - Yp0[0])**2 /
1E8) * 1 / sqrt(2 * pi * S.sqrt(1E8))
D0 = S.log(D0)
D1 = c * S.exp(-0.5 * (M1R[1][:, I] - Yp1[0])**2 /
Yp1[1]) * 1 / sqrt(2 * S.pi * Yp1[1])
D1 += (1 - c) * S.exp(-0.5 * (M1R[1][:, I] - Yp1[0])**2 /
1E8) * 1 / sqrt(2 * pi * S.sqrt(1E8))
D1 = S.log(D1)
DJ = c * S.exp(-0.5 * (MJR[1][:, I] - Ypj[0])**2 /
Ypj[1]) * 1 / sqrt(2 * S.pi * Ypj[1])
DJ += (1 - c) * S.exp(-0.5 * (MJR[1][:, I] - Ypj[0])**2 /
1E8) * 1 / sqrt(2 * pi * S.sqrt(1E8))
DJ = S.log(DJ)
DS = D0.sum(axis=0) + D1.sum(axis=0)
DJ = DJ.sum(axis=0)
ES = S.exp(DS)
EJ = S.exp(DJ)
PZ[0, :] = self.prior_Z[0] * EJ
PZ[1, :] = self.prior_Z[1] * ES
PZ /= PZ.sum(axis=0)
#sample indicators
Z = S.rand(I.sum()) <= PZ[1, :]
if (IS_.sum() == 1):
Z = True
if (IJ_.sum() == 1):
Z = False
return [Z, PZ]
pass
pass
#1. use the standard method to initialise the GP objects
ratio = self.test(M0, M1, verbose=verbose, opt=opt)
GP0 = CP.deepcopy(self.gpr_0)
GP1 = CP.deepcopy(self.gpr_1)
GPJ = CP.deepcopy(self.gpr_join)
#2. initialise gibbs samplign for time-local approximation
#get set of unique time coordinates
XT = M0[0][0].reshape([-1, 1])
#rescale all datasets inputs
MJ = [
S.concatenate((M0[0], M1[0]), axis=0),
S.concatenate((M0[1], M1[1]), axis=0)
]
MJR = CP.deepcopy(MJ)
M0R = CP.deepcopy(M0)
M1R = CP.deepcopy(M1)
#rescale and 0 mean
MJR[0] = rescaleInputs(MJ[0], self.gpr_join)
M0R[0] = rescaleInputs(M0[0], self.gpr_0)
M1R[0] = rescaleInputs(M1[0], self.gpr_1)
MJR[1] -= self.gpr_join.mean
M0R[1] -= self.gpr_0.mean
M1R[1] -= self.gpr_1.mean
#index vector assigning each time point to either expert
IS = S.ones([XT.shape[0]], dtype='bool')
IJ = S.ones([XT.shape[0]], dtype='bool')
#1. sample all indicators conditioned on current GP approximation
Z_ = sampleIndicator(S.ones(XT.shape[0], dtype='bool'), take_out=False)
Z_ = S.random.rand(IS.shape[0]) > 0.5
PZ = S.zeros([2, IS.shape[0]])
Z = S.zeros([Ngibbs_iterations, IS.shape[0]], dtype='bool')
#update the datasets in the GP, attention: rescaling might cause trouble here..
IS[~Z_] = False
IJ[Z_] = False
#sample indicators one by one
for n in range(Ngibbs_iterations):
# for i in random.permutation(IS.shape[0]):
for i in S.arange(IS.shape[0]):
#resample a single indicator
I = S.zeros([IS.shape[0]], dtype='bool')
I[i] = True
[Z_, PZ_] = sampleIndicator(I)
#save prob. and indicator value
PZ[:, i] = S.squeeze(PZ_)
Z[n, i] = S.squeeze(Z_)
#update indicators
IS[i] = Z_
IJ[i] = ~Z_
LG.debug("Gibbs iteration:%d" % (n))
LG.debug(PZ)
LG.debug(IS)
n_ = round(Ngibbs_iterations) / 2
Z = Z[n_::]
PZ[1, :] = Z.mean(axis=0)
PZ[0, :] = 1 - PZ[1, :]
GP0 = self.gpr_0
GP1 = self.gpr_1
GPJ = self.gpr_join
if verbose:
PL.clf()
#1. plot the gp predictions
ax1 = PL.axes([0.1, 0.1, 0.8, 0.7])
Xt_ = S.linspace(0, XT[:, 0].max() + 2, 100)
Xt = Xt_.reshape([-1, 1])
self.plotGPpredict(GP0, M0, Xt, {
'alpha': 0.1,
'facecolor': 'r'
}, {
'linewidth': 2,
'color': 'r'
})
self.plotGPpredict(GP1, M0, Xt, {
'alpha': 0.1,
'facecolor': 'g'
}, {
'linewidth': 2,
'color': 'g'
})
self.plotGPpredict(GPJ, M0, Xt, {
'alpha': 0.1,
'facecolor': 'k'
}, {
'linewidth': 2,
'color': 'k'
})
PL.plot(M0[0].T, M0[1].T, 'r.--')
PL.plot(M1[0].T, M1[1].T, 'g.--')
PL.xlim([Xt.min(), Xt.max()])
#remove last ytick to avoid overlap
yticks = ax1.get_yticks()[0:-2]
ax1.set_yticks(yticks)
xlabel('Time/h')
ylabel('Log expression level')
Ymax = MJ[1].max()
Ymin = MJ[1].min()
DY = Ymax - Ymin
PL.ylim([Ymin - 0.1 * DY, Ymax + 0.1 * DY])
#now plot hinton diagram with responsibilities on top
ax2 = PL.axes([0.1, 0.715, 0.8, 0.2], sharex=ax1)
# ax2=PL.axes([0.1,0.7,0.8,0.2])
#PL.plot(XT[:,0],Z[1,:])
#swap the order of Z for optical purposes
Z_ = S.ones_like(PZ)
Z_[1, :] = PZ[0, :]
Z_[0, :] = PZ[1, :]
hinton(Z_, X=M0[0][0])
ylabel('diff.')
#hide axis labels
setp(ax2.get_xticklabels(), visible=False)
#font size
#setp( ax1.get_xticklabels(), fontsize=tickSize)
#setp( ax1.get_yticklabels(), fontsize=tickSize)
#setp( ax2.get_xticklabels(), fontsize=tickSize)
#PL.ylim(Ymin-0.1*DY,Ymax+0.1*DY)
return [ratio, PZ]
pass
