def build_predict(self,Xnew,task_ind):
"""
We need to assume the task_ind starts from 0
"""
Fmean,Fvar = 0,0
for i in np.arange(self.rank):
for j in np.arange(self.num_latent_list[i]):
lat_id = np.sum(self.num_latent_list[:i],dtype = np.int64) + j
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(Xnew, self.Z[lat_id],
self.kern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(Xnew, self.Z[lat_id],
self.kern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id],1)
W_ij = tf.gather(self.W,task_ind)[lat_id]
Fmean += (fmean + self.mean_function_list[lat_id](Xnew))*W_ij
Fvar += fvar * tf.square(W_ij)
if self.tsk:
for i in np.arange(self.num_tasks):
lat_id = np.sum(self.num_latent_list,dtype = np.int64) + i
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(Xnew, self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(Xnew, self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
switch = tf.cast(tf.equal(tf.to_int64(i), task_ind),tf.float64)
W_ij = tf.gather(self.Kappa,i)[0]*switch
Fmean += (fmean + self.mean_function_list[lat_id](Xnew))*W_ij
Fvar += fvar * tf.square(W_ij)
return Fmean, Fvar
def build_predict(self, Xnew):
mu = None
var = None
for d in xrange(self.X.shape[1]):
xnew_d_as_2d = Xnew[:, d].reshape(len(Xnew), 1)
q_mu_d = self.__getattribute__('q_mu_%d' % d)
q_sqrt_d = self.__getattribute__('q_sqrt_%d' % d)
Z_d = self.__getattribute__('Z_%d' % d)
if self.whiten:
mu_d, var_d = conditionals.gaussian_gp_predict_whitened(xnew_d_as_2d, Z_d, self.kern[d], q_mu_d, q_sqrt_d, self.num_latent)
else:
mu_d, var_d = conditionals.gaussian_gp_predict(xnew_d_as_2d, Z_d, self.kern[d], q_mu_d, q_sqrt_d, self.num_latent)
mu_d += self.mean_function[d](xnew_d_as_2d)
# add things up, we were too lazy to check the type of fmean_d, fvar_d
if mu is None or var is None:
mu = mu_d
var = var_d
else:
mu += mu_d
var += var_d
return mu, var
def build_likelihood(self):
"""
This gives a variational bound on the model likelihood.
"""
#Get prior KL.
KL = self.build_prior_KL()
#Get conditionals
if self.whiten:
fmean, fvar = conditionals.gaussian_gp_predict_whitened(
self._tfX, self.Z, self.kern, self.q_mu, self.q_sqrt,
self.num_latent)
else:
fmean, fvar = conditionals.gaussian_gp_predict(
self._tfX, self.Z, self.kern, self.q_mu, self.q_sqrt,
self.num_latent)
#add in mean function to conditionals.
fmean += self.mean_function(self._tfX)
#Get variational expectations.
variational_expectations = self.likelihood.variational_expectations(
fmean, fvar, self._tfY)
minibatch_scale = len(self.X) / tf.cast(
tf.shape(self._tfX)[0], tf.float64)
return tf.reduce_sum(variational_expectations) * minibatch_scale - KL
def build_likelihood(self):
"""
This gives a variational bound on the model likelihood.
"""
#Get prior KL.
KL = self.build_prior_KL()
#Get conditionals
if self.whiten:
fmean, fvar = conditionals.gaussian_gp_predict_whitened(
self.X, self.Z, self.kern, self.q_mu, self.q_sqrt,
self.num_latent)
else:
fmean, fvar = conditionals.gaussian_gp_predict(
self.X, self.Z, self.kern, self.q_mu, self.q_sqrt,
self.num_latent)
#add in mean function to conditionals.
fmean += self.mean_function(self.X)
#Get variational expectations.
variational_expectations = self.likelihood.variational_expectations(
fmean, fvar, self.Y)
return tf.reduce_sum(variational_expectations) - KL
def build_predict(self, Xnew):
if self.whiten:
mu, var = conditionals.gaussian_gp_predict_whitened(
Xnew, self.Z, self.kern, self.q_mu, self.q_sqrt,
self.num_latent)
else:
mu, var = conditionals.gaussian_gp_predict(Xnew, self.Z, self.kern,
self.q_mu, self.q_sqrt,
self.num_latent)
return mu + self.mean_function(Xnew), var
def build_likelihood(self):
"""
Loglikelihood is the likelihood sum over all tasks
the outer loop go through all the tasks and the inner loop goes through
the latent function inside each task and calculate the loglike of this task
as the weighted sum of loglike of latent function.
"""
#Get prior KL.
KL,loglike = self.build_prior_KL(),0
self.Xt = [tf.placeholder(dtype = tf.float64, shape = [None,1]) for _ in np.arange(self.num_tasks)]
self.Yt = [tf.placeholder(dtype = tf.float64, shape = [None,1]) for _ in np.arange(self.num_tasks)]
#Get conditionals, is this correct???
for d in np.arange(self.num_tasks):
ve,Fmean,Fvar = 0,0,0
lag = self.lagging[d,0]
for q in np.arange(self.rank):
for i in np.arange(self.num_latent_list[q]):
lat_id = np.sum(self.num_latent_list[:q],dtype = np.int64) + i
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.Xt[d]-lag, self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.Xt[d]-lag,self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
Fmean += (fmean + self.mean_function_list[lat_id](self.Xt[d]))*self.W[d,lat_id]
Fvar += fvar * tf.square(self.W[d,lat_id])
if self.tsk:
lat_id = np.sum(self.num_latent_list,dtype = np.int64) + d
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.Xt[d], self.Z[lat_id],
self.tskern_list[d], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.Xt[d], self.Z[lat_id],
self.tskern_list[d], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
Fmean += (fmean + self.mean_function_list[lat_id](self.Xt[d]))*self.Kappa[d,0]
Fvar += fvar * tf.square(self.Kappa[d,0])
ve = self.likelihood[d].variational_expectations(Fmean, Fvar, self.Yt[d])
loglike += tf.reduce_sum(ve)
"""add time to event likelihood to the loglike"""
#return loglike - KL - self.lamda *tf.sqrt(tf.reduce_sum(tf.square(self.Kappa)))/self.num_patients
return loglike - KL
def build_likelihood(self):
"""
Loglikelihood is the likelihood sum over all tasks
the outer loop go through all the tasks and the inner loop goes through
the latent function inside each task and calculate the loglike of this task
as the weighted sum of loglike of latent function.
"""
#Get prior KL.
KL,loglike = self.build_prior_KL(),0
#Get conditionals
for i in np.arange(self.num_tasks):
ve,Fmean,Fvar = 0,0,0
for j in np.arange(self.rank):
for k in np.arange(self.num_latent_list[j]):
lat_id = np.sum(self.num_latent_list[:j],dtype = np.int64) + k
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.X[i], self.Z[lat_id],
self.kern_list[j], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.X[i], self.Z[lat_id],
self.kern_list[j], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
Fmean += (fmean + self.mean_function_list[lat_id](self.X[i]))*self.W[i,lat_id]
Fvar += fvar * tf.square(self.W[i,lat_id])
if self.tsk:
lat_id = np.sum(self.num_latent_list,dtype = np.int64) + i
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.X[i], self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.X[i], self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
Fmean += (fmean + self.mean_function_list[lat_id](self.X[i]))*self.Kappa[i,0]
Fvar += fvar * tf.square(self.Kappa[i,0])
ve = self.likelihood[i].variational_expectations(Fmean, Fvar, self.Y[i])
loglike += tf.reduce_sum(ve)
loglike -= KL
return loglike
def predict_task_latent(self,Xnew,task_id):
Fmean,Fvar = 0,0
for i in xrange(self.num_tasks):
switch = tf.cast(tf.equal(np.int64(i),tf.to_int64(task_id)),tf.float64)
lat_id = np.sum(self.num_latent_list) + i
if self.whiten_list[lat_id]:
fmean,fvar = conditionals.gaussian_gp_predict_whitened(Xnew, self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id],1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(Xnew, self.Z[lat_id],
self.tskern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
Fmean += fmean*switch
Fvar += fvar*switch
return Fmean, Fvar
def predict_latent(self, Xnew, group_id, ingroup_id):
"""
Compute the posterior for one of the latent functions.
"""
Fmean, Fvar = 0,0
for i in np.arange(self.rank):
switch1 = tf.cast(tf.equal(i, group_id),tf.float64)
for j in np.arange(self.num_latent_list[i]):
lat_id = np.sum(self.num_latent_list[:i],dtype = np.int64) + j
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(Xnew, self.Z[lat_id],
self.kern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(Xnew, self.Z[lat_id],
self.kern_list[i], self.q_mu_list[lat_id],
self.q_sqrt_list[lat_id], 1)
switch2 = tf.cast(tf.equal(j, ingroup_id),tf.float64)
Fmean += (fmean + self.mean_function_list[lat_id](Xnew))*switch1*switch2
Fvar += fvar *switch1*switch2
return Fmean, Fvar
def build_likelihood(self):
"""
This gives a variational bound on the model likelihood.
"""
#Get prior KL.
KL = self.build_prior_KL()
#Get conditionals
if self.whiten:
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.X, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.X, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent)
#add in mean function to conditionals.
fmean += self.mean_function(self.X)
#Get variational expectations.
variational_expectations = self.likelihood.variational_expectations(fmean, fvar, self.Y)
return tf.reduce_sum(variational_expectations) - KL
def build_likelihood(self):
"""
This gives a variational bound on the model likelihood.
"""
#Get prior KL.
KL = self.build_prior_KL()
#Get conditionals
if self.whiten:
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self._tfX, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self._tfX, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent)
#add in mean function to conditionals.
fmean += self.mean_function(self._tfX)
#Get variational expectations.
variational_expectations = self.likelihood.variational_expectations(fmean, fvar, self._tfY)
minibatch_scale = len(self.X) / tf.cast(tf.shape(self._tfX)[0], tf.float64)
return tf.reduce_sum(variational_expectations) * minibatch_scale - KL
def build_likelihood(self):
"""
This gives a variational bound on the model likelihood.
"""
# Get prior KL.
KL = self.build_prior_KL()
fmean = None
fvar = None
for d in xrange(self.X.shape[1]):
x_d_as_2d = self.X[:, d].reshape(len(self.X), 1)
q_mu_d = self.__getattribute__('q_mu_%d' % d)
q_sqrt_d = self.__getattribute__('q_sqrt_%d' % d)
Z_d = self.__getattribute__('Z_%d' % d)
# Get conditionals
if self.whiten:
fmean_d, fvar_d = conditionals.gaussian_gp_predict_whitened(x_d_as_2d, Z_d, self.kern[d], q_mu_d, q_sqrt_d, self.num_latent)
else:
fmean_d, fvar_d = conditionals.gaussian_gp_predict(x_d_as_2d, Z_d, self.kern[d], q_mu_d, q_sqrt_d, self.num_latent)
# add in mean function to conditionals.
fmean_d += self.mean_function(x_d_as_2d)
# add things up, we were too lazy to check the type of fmean_d, fvar_d
if fmean is None or fvar is None:
fmean = fmean_d
fvar = fvar_d
else:
fmean += fmean_d
fvar += fvar_d
# Get variational expectations.
variational_expectations = self.likelihood.variational_expectations(fmean, fvar, self.Y)
return tf.reduce_sum(variational_expectations) - KL
def build_predict(self, Xnew, full_cov=False):
if self.whiten:
mu, var = conditionals.gaussian_gp_predict_whitened(Xnew, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent, full_cov)
else:
mu, var = conditionals.gaussian_gp_predict(Xnew, self.Z, self.kern, self.q_mu, self.q_sqrt, self.num_latent, full_cov)
return mu + self.mean_function(Xnew), var
def build_likelihood(self):
"""
Loglikelihood is the likelihood sum over all tasks
the outer loop go through all the tasks and the inner loop goes through
the latent function inside each task and calculate the loglike of this task
as the weighted sum of loglike of latent function.
"""
#Get prior KL.
def quardrature_tensorflow(a,b,num_points):
"""
Gaussian Quardrature in 1d
"""
x, w = leggauss(num_points)
x = tf.reshape((b-a)/2.*x + (a+b)/2.,[-1,1])
w = tf.reshape(w,[1,-1])*(b-a)/2
#res = tf.matmul(w,fun(x)).
return x,w
KL,loglike = self.build_prior_KL(),0
self.Xt = [tf.placeholder(dtype = tf.float64, shape = [None,1]) for _ in np.arange(self.num_tasks)]
self.Yt = [tf.placeholder(dtype = tf.float64, shape = [None,1]) for _ in np.arange(self.num_tasks)]
self.Tt = tf.placeholder(dtype = tf.float64, shape = [1,1])
self.invariant_t = tf.placeholder(dtype = tf.float64, shape = [None,1])
self.event_t = tf.placeholder(dtype = tf.float64,shape = [1,1])
x, w = quardrature_tensorflow(0,self.Tt,self.num_inducing_points)
time2event,time2event2 = 0 , 0
#Get conditionals, is this correct???
Fmean_joint = np.zeros(shape = (self.num_tasks,1))
Fvar_joint = np.zeros(shape = (self.num_tasks,self.num_tasks))
"""
Can we creat a list to contain fexp_var for computing the full convariance matrix?
"""
fexp_list = list()
for d in np.arange(self.num_tasks):
ve,Fmean,Fvar,fvar_joint = 0,0,0,0
lag = self.lagging[d,0]
for q in np.arange(self.rank):
for i in np.arange(self.num_latent_list[q]):
lat_id = np.sum(self.num_latent_list[:q],dtype = np.int64) + i
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.Xt[d]-lag, self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
if d == 0:
fexp, fexp_var = conditionals.gaussian_gp_predict_whitened(x, self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
fexp_list.append(fexp_var)
Fvar_joint[d,d] += fexp_var* tf.square(self.W[d,lat_id])
else:
for k in np.arange(d):
fvar_joint = fexp_list[lat_id]*self.W[d,lat_id] *self.W[k,lat_id]
Fvar_joint[d,k] += fvar_joint
Fvar_joint[k,d] += fvar_joint
fm = tf.gather(fexp,self.num_inducing_points-1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.Xt[d]-lag,self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
if d == 0:
fexp, fexp_var = conditionals.gaussian_gp_predict(x, self.Z[lat_id], self.kern_list[q],
self.q_mu_list[lat_id], self.q_sqrt_list[lat_id],1) ## tf.matmul(w,fexp, fexp_var)
fexp_list.append(fexp_var)
Fvar_joint[d,d] += fexp_var* tf.square(self.W[d,lat_id])
else:
for k in np.arange(d):
fvar_joint = fexp_list[lat_id]*self.W[d,lat_id] *self.W[k,lat_id]
Fvar_joint[d,k] += fvar_joint
Fvar_joint[k,d] += fvar_joint
fm = tf.gather(fexp,self.num_inducing_points-1)
Fmean += (fmean + self.mean_function_list[lat_id](self.Xt[d]))*self.W[d,lat_id]
Fvar += fvar * tf.square(self.W[d,lat_id])
fexp += (fmean + self.mean_function_list[lat_id](x))*self.W[d,lat_id]*self.alpha[d]
time2event += fm + self.mean_function_list[lat_id](self.Tt[d])*self.W[d,lat_id]* self.alpha[d]*self.event_t
if self.tsk:
lat_id = np.sum(self.num_latent_list,dtype = np.int64) + d
if self.whiten_list[lat_id]: # need to compute fmean and fvar by the weights
fmean, fvar = conditionals.gaussian_gp_predict_whitened(self.Xt[d], self.Z[lat_id],
self.tskern_list[d], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
fexp, fexp_var = conditionals.gaussian_gp_predict_whitened(x, self.Z[lat_id],
self.kern_list[q], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
Fvar_joint[d,d] += fexp_var *tf.square(self.W[d,lat_id])
fm = tf.gather(fexp,self.num_inducing_points-1)
else:
fmean, fvar = conditionals.gaussian_gp_predict(self.Xt[d], self.Z[lat_id],
self.tskern_list[d], self.q_mu_list[lat_id], self.q_sqrt_list[lat_id], 1)
fexp, fexp_var = conditionals.gaussian_gp_predict(x, self.Z[lat_id], self.kern_list[q],
self.q_mu_list[lat_id], self.q_sqrt_list[lat_id],1) #wrong ,need to rewrite
Fvar_joint[d,d] += fexp_var *tf.square(self.W[d,lat_id])
fm = tf.gather(fexp,self.num_inducing_points-1) # wrong, need to be rewrite
Fmean += (fmean + self.mean_function_list[lat_id](self.Xt[d]))*self.Kappa[d,0]
Fvar += fvar * tf.square(self.Kappa[d,0])
time2event += fm + self.mean_function_list[lat_id](self.Tt[d])*self.W[d,lat_id]* self.alpha[d]*self.event_t
time2event += self.gamma[d] * self.invariant_t*self.event_t
Fmean_joint[d,0] = fexp
ve = self.likelihood[d].variational_expectations(Fmean, Fvar, self.Yt[d])
loglike += tf.reduce_sum(ve)
loglike -= tf.matmul(w,time2event2) # minus the second part
loglike += tf.log(h_fun(self.Tt))*self.event_t + time2event
"""add time to event likelihood to the loglike"""
return loglike - KL - self.lamda *tf.sqrt(tf.reduce_sum(tf.square(self.Kappa)))