mirror of
https://github.com/SheffieldML/GPy.git
synced 2026-07-11 16:22:13 +02:00
the implementation of SVI-MOGP
This commit is contained in:
Zhenwen Dai
parent
6cc13af8cd
commit
c294cf715f
9 changed files with 1295 additions and 8 deletions
|
|
@ -91,6 +91,8 @@ from .pep import PEP
|
|||
from .var_dtc_parallel import VarDTC_minibatch
|
||||
from .var_gauss import VarGauss
|
||||
from .gaussian_grid_inference import GaussianGridInference
|
||||
from .vardtc_svi_multiout import VarDTC_SVI_Multiout
|
||||
from .vardtc_svi_multiout_miss import VarDTC_SVI_Multiout_Miss
|
||||
|
||||
|
||||
# class FullLatentFunctionData(object):
|
||||
|
|
|
|||
177
GPy/inference/latent_function_inference/vardtc_md.py
Normal file
177
GPy/inference/latent_function_inference/vardtc_md.py
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
|
||||
|
||||
|
||||
from GPy.util.linalg import jitchol, backsub_both_sides, tdot, dtrtrs, dtrtri,pdinv, dpotri
|
||||
from GPy.util import diag
|
||||
from GPy.core.parameterization.variational import VariationalPosterior
|
||||
import numpy as np
|
||||
from GPy.inference.latent_function_inference import LatentFunctionInference
|
||||
from GPy.inference.latent_function_inference.posterior import Posterior
|
||||
|
||||
log_2_pi = np.log(2*np.pi)
|
||||
|
||||
class VarDTC_MD(LatentFunctionInference):
|
||||
"""
|
||||
An object for inference when the likelihood is Gaussian, but we want to do sparse inference.
|
||||
|
||||
The function self.inference returns a Posterior object, which summarizes
|
||||
the posterior.
|
||||
|
||||
For efficiency, we sometimes work with the cholesky of Y*Y.T. To save repeatedly recomputing this, we cache it.
|
||||
|
||||
"""
|
||||
const_jitter = 1e-6
|
||||
|
||||
def gatherPsiStat(self, kern, X, Z, Y, beta, uncertain_inputs):
|
||||
|
||||
if uncertain_inputs:
|
||||
psi0 = kern.psi0(Z, X)
|
||||
psi1 = kern.psi1(Z, X)
|
||||
psi2 = kern.psi2n(Z, X)
|
||||
else:
|
||||
psi0 = kern.Kdiag(X)
|
||||
psi1 = kern.K(X, Z)
|
||||
psi2 = psi1[:,:,None]*psi1[:,None,:]
|
||||
|
||||
return psi0, psi1, psi2
|
||||
|
||||
def inference(self, kern, X, Z, likelihood, Y, indexD, output_dim, Y_metadata=None, Lm=None, dL_dKmm=None, Kuu_sigma=None):
|
||||
"""
|
||||
The first phase of inference:
|
||||
Compute: log-likelihood, dL_dKmm
|
||||
|
||||
Cached intermediate results: Kmm, KmmInv,
|
||||
"""
|
||||
|
||||
input_dim = Z.shape[0]
|
||||
|
||||
uncertain_inputs = isinstance(X, VariationalPosterior)
|
||||
|
||||
beta = 1./likelihood.variance
|
||||
if len(beta)==1:
|
||||
beta = np.zeros(output_dim)+beta
|
||||
|
||||
beta_exp = np.zeros(indexD.shape[0])
|
||||
for d in range(output_dim):
|
||||
beta_exp[indexD==d] = beta[d]
|
||||
|
||||
psi0, psi1, psi2 = self.gatherPsiStat(kern, X, Z, Y, beta, uncertain_inputs)
|
||||
|
||||
psi2_sum = (beta_exp[:,None,None]*psi2).sum(0)/output_dim
|
||||
|
||||
#======================================================================
|
||||
# Compute Common Components
|
||||
#======================================================================
|
||||
|
||||
Kmm = kern.K(Z).copy()
|
||||
if Kuu_sigma is not None:
|
||||
diag.add(Kmm, Kuu_sigma)
|
||||
else:
|
||||
diag.add(Kmm, self.const_jitter)
|
||||
Lm = jitchol(Kmm)
|
||||
|
||||
logL = 0.
|
||||
dL_dthetaL = np.zeros(output_dim)
|
||||
dL_dKmm = np.zeros_like(Kmm)
|
||||
dL_dpsi0 = np.zeros_like(psi0)
|
||||
dL_dpsi1 = np.zeros_like(psi1)
|
||||
dL_dpsi2 = np.zeros_like(psi2)
|
||||
wv = np.empty((Kmm.shape[0],output_dim))
|
||||
|
||||
for d in range(output_dim):
|
||||
idx_d = indexD==d
|
||||
Y_d = Y[idx_d]
|
||||
N_d = Y_d.shape[0]
|
||||
beta_d = beta[d]
|
||||
|
||||
psi2_d = psi2[idx_d].sum(0)*beta_d
|
||||
psi1Y = Y_d.T.dot(psi1[idx_d])*beta_d
|
||||
psi0_d = psi0[idx_d].sum()*beta_d
|
||||
YRY_d = np.square(Y_d).sum()*beta_d
|
||||
|
||||
LmInvPsi2LmInvT = backsub_both_sides(Lm, psi2_d, 'right')
|
||||
|
||||
Lambda = np.eye(Kmm.shape[0])+LmInvPsi2LmInvT
|
||||
LL = jitchol(Lambda)
|
||||
LmLL = Lm.dot(LL)
|
||||
|
||||
b = dtrtrs(LmLL, psi1Y.T)[0].T
|
||||
bbt = np.square(b).sum()
|
||||
v = dtrtrs(LmLL, b.T, trans=1)[0].T
|
||||
LLinvPsi1TYYTPsi1LLinvT = tdot(b.T)
|
||||
|
||||
tmp = -backsub_both_sides(LL, LLinvPsi1TYYTPsi1LLinvT)
|
||||
dL_dpsi2R = backsub_both_sides(Lm, tmp+np.eye(input_dim))/2
|
||||
|
||||
logL_R = -N_d*np.log(beta_d)
|
||||
logL += -((N_d*log_2_pi+logL_R+psi0_d-np.trace(LmInvPsi2LmInvT))+YRY_d- bbt)/2.
|
||||
|
||||
dL_dKmm += dL_dpsi2R - backsub_both_sides(Lm, LmInvPsi2LmInvT)/2
|
||||
|
||||
dL_dthetaL[d:d+1] = (YRY_d*beta_d + beta_d*psi0_d - N_d*beta_d)/2. - beta_d*(dL_dpsi2R*psi2_d).sum() - beta_d*np.trace(LLinvPsi1TYYTPsi1LLinvT)
|
||||
|
||||
dL_dpsi0[idx_d] = -beta_d/2.
|
||||
dL_dpsi1[idx_d] = beta_d*np.dot(Y_d,v)
|
||||
dL_dpsi2[idx_d] = beta_d*dL_dpsi2R
|
||||
wv[:,d] = v
|
||||
|
||||
LmInvPsi2LmInvT = backsub_both_sides(Lm, psi2_sum, 'right')
|
||||
|
||||
Lambda = np.eye(Kmm.shape[0])+LmInvPsi2LmInvT
|
||||
LL = jitchol(Lambda)
|
||||
LmLL = Lm.dot(LL)
|
||||
logdet_L = 2.*np.sum(np.log(np.diag(LL)))
|
||||
dL_dpsi2R_common = dpotri(LmLL)[0]/-2.
|
||||
dL_dpsi2 += dL_dpsi2R_common[None,:,:]*beta_exp[:,None,None]
|
||||
|
||||
for d in range(output_dim):
|
||||
dL_dthetaL[d] += (dL_dpsi2R_common*psi2[indexD==d].sum(0)).sum()*-beta[d]*beta[d]
|
||||
|
||||
dL_dKmm += dL_dpsi2R_common*output_dim
|
||||
|
||||
logL += -output_dim*logdet_L/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dKmm
|
||||
#======================================================================
|
||||
|
||||
# dL_dKmm = dL_dpsi2R - output_dim* backsub_both_sides(Lm, LmInvPsi2LmInvT)/2 #LmInv.T.dot(LmInvPsi2LmInvT).dot(LmInv)/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute the Posterior distribution of inducing points p(u|Y)
|
||||
#======================================================================
|
||||
|
||||
LLInvLmT = dtrtrs(LL, Lm.T)[0]
|
||||
cov = tdot(LLInvLmT.T)
|
||||
|
||||
wd_inv = backsub_both_sides(Lm, np.eye(input_dim)- backsub_both_sides(LL, np.identity(input_dim), transpose='left'), transpose='left')
|
||||
post = Posterior(woodbury_inv=wd_inv, woodbury_vector=wv, K=Kmm, mean=None, cov=cov, K_chol=Lm)
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dthetaL for uncertian input and non-heter noise
|
||||
#======================================================================
|
||||
|
||||
# for d in range(output_dim):
|
||||
# dL_dthetaL[d:d+1] += - beta[d]*beta[d]*(dL_dpsi2R[None,:,:] * psi2[indexD==d]/output_dim).sum()
|
||||
# dL_dthetaL += - (dL_dpsi2R[None,:,:] * psi2_sum*D beta*(dL_dpsi2R*psi2).sum()
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dpsi
|
||||
#======================================================================
|
||||
|
||||
if not uncertain_inputs:
|
||||
dL_dpsi1 += (psi1[:,None,:]*dL_dpsi2).sum(2)*2.
|
||||
|
||||
if uncertain_inputs:
|
||||
grad_dict = {'dL_dKmm': dL_dKmm,
|
||||
'dL_dpsi0':dL_dpsi0,
|
||||
'dL_dpsi1':dL_dpsi1,
|
||||
'dL_dpsi2':dL_dpsi2,
|
||||
'dL_dthetaL':dL_dthetaL}
|
||||
else:
|
||||
grad_dict = {'dL_dKmm': dL_dKmm,
|
||||
'dL_dKdiag':dL_dpsi0,
|
||||
'dL_dKnm':dL_dpsi1,
|
||||
'dL_dthetaL':dL_dthetaL}
|
||||
|
||||
return post, logL, grad_dict
|
||||
271
GPy/inference/latent_function_inference/vardtc_svi_multiout.py
Normal file
271
GPy/inference/latent_function_inference/vardtc_svi_multiout.py
Normal file
|
|
@ -0,0 +1,271 @@
|
|||
#from .posterior import Posterior
|
||||
from GPy.util.linalg import jitchol, backsub_both_sides, tdot, dtrtrs, dtrtri,pdinv, dpotri
|
||||
from GPy.util import diag
|
||||
from GPy.core.parameterization.variational import VariationalPosterior
|
||||
import numpy as np
|
||||
from GPy.inference.latent_function_inference import LatentFunctionInference
|
||||
from GPy.inference.latent_function_inference.posterior import Posterior
|
||||
log_2_pi = np.log(2*np.pi)
|
||||
|
||||
|
||||
class VarDTC_SVI_Multiout(LatentFunctionInference):
|
||||
"""
|
||||
An object for inference when the likelihood is Gaussian, but we want to do sparse inference.
|
||||
|
||||
The function self.inference returns a Posterior object, which summarizes
|
||||
the posterior.
|
||||
|
||||
For efficiency, we sometimes work with the cholesky of Y*Y.T. To save repeatedly recomputing this, we cache it.
|
||||
|
||||
"""
|
||||
const_jitter = 1e-6
|
||||
|
||||
def get_trYYT(self, Y):
|
||||
return np.sum(np.square(Y))
|
||||
|
||||
def get_YYTfactor(self, Y):
|
||||
N, D = Y.shape
|
||||
if (N>=D):
|
||||
return Y.view(np.ndarray)
|
||||
else:
|
||||
return jitchol(tdot(Y))
|
||||
|
||||
def gatherPsiStat(self, kern, X, Z, uncertain_inputs):
|
||||
|
||||
if uncertain_inputs:
|
||||
psi0 = kern.psi0(Z, X).sum()
|
||||
psi1 = kern.psi1(Z, X)
|
||||
psi2 = kern.psi2(Z, X)
|
||||
else:
|
||||
psi0 = kern.Kdiag(X).sum()
|
||||
psi1 = kern.K(X, Z)
|
||||
psi2 = tdot(psi1.T)
|
||||
|
||||
return psi0, psi1, psi2
|
||||
|
||||
def inference(self, kern_r, kern_c, Xr, Xc, Zr, Zc, likelihood, Y, qU_mean ,qU_var_r, qU_var_c):
|
||||
"""
|
||||
The SVI-VarDTC inference
|
||||
"""
|
||||
|
||||
N, D, Mr, Mc, Qr, Qc = Y.shape[0], Y.shape[1], Zr.shape[0], Zc.shape[0], Zr.shape[1], Zc.shape[1]
|
||||
|
||||
uncertain_inputs_r = isinstance(Xr, VariationalPosterior)
|
||||
uncertain_inputs_c = isinstance(Xc, VariationalPosterior)
|
||||
uncertain_outputs = isinstance(Y, VariationalPosterior)
|
||||
|
||||
beta = 1./likelihood.variance
|
||||
|
||||
psi0_r, psi1_r, psi2_r = self.gatherPsiStat(kern_r, Xr, Zr, uncertain_inputs_r)
|
||||
psi0_c, psi1_c, psi2_c = self.gatherPsiStat(kern_c, Xc, Zc, uncertain_inputs_c)
|
||||
|
||||
#======================================================================
|
||||
# Compute Common Components
|
||||
#======================================================================
|
||||
|
||||
Kuu_r = kern_r.K(Zr).copy()
|
||||
diag.add(Kuu_r, self.const_jitter)
|
||||
Lr = jitchol(Kuu_r)
|
||||
|
||||
Kuu_c = kern_c.K(Zc).copy()
|
||||
diag.add(Kuu_c, self.const_jitter)
|
||||
Lc = jitchol(Kuu_c)
|
||||
|
||||
mu, Sr, Sc = qU_mean, qU_var_r, qU_var_c
|
||||
LSr = jitchol(Sr)
|
||||
LSc = jitchol(Sc)
|
||||
|
||||
LcInvMLrInvT = dtrtrs(Lc,dtrtrs(Lr,mu.T)[0].T)[0]
|
||||
LcInvPsi2_cLcInvT = backsub_both_sides(Lc, psi2_c,'right')
|
||||
LrInvPsi2_rLrInvT = backsub_both_sides(Lr, psi2_r,'right')
|
||||
LcInvLSc = dtrtrs(Lc, LSc)[0]
|
||||
LrInvLSr = dtrtrs(Lr, LSr)[0]
|
||||
LcInvScLcInvT = tdot(LcInvLSc)
|
||||
LrInvSrLrInvT = tdot(LrInvLSr)
|
||||
LcInvPsi1_cT = dtrtrs(Lc, psi1_c.T)[0]
|
||||
LrInvPsi1_rT = dtrtrs(Lr, psi1_r.T)[0]
|
||||
|
||||
tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT = (LrInvPsi2_rLrInvT*LrInvSrLrInvT).sum()
|
||||
tr_LcInvPsi2_cLcInvT_LcInvScLcInvT = (LcInvPsi2_cLcInvT*LcInvScLcInvT).sum()
|
||||
tr_LrInvSrLrInvT = np.square(LrInvLSr).sum()
|
||||
tr_LcInvScLcInvT = np.square(LcInvLSc).sum()
|
||||
tr_LrInvPsi2_rLrInvT = np.trace(LrInvPsi2_rLrInvT)
|
||||
tr_LcInvPsi2_cLcInvT = np.trace(LcInvPsi2_cLcInvT)
|
||||
|
||||
#======================================================================
|
||||
# Compute log-likelihood
|
||||
#======================================================================
|
||||
|
||||
logL_A = - np.square(Y).sum() \
|
||||
- (LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT)*LrInvPsi2_rLrInvT).sum() \
|
||||
- tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT* tr_LcInvPsi2_cLcInvT_LcInvScLcInvT \
|
||||
+ 2 * (Y * LcInvPsi1_cT.T.dot(LcInvMLrInvT).dot(LrInvPsi1_rT)).sum() - psi0_c * psi0_r \
|
||||
+ tr_LrInvPsi2_rLrInvT * tr_LcInvPsi2_cLcInvT
|
||||
|
||||
logL = -N*D/2.*(np.log(2.*np.pi)-np.log(beta)) + beta/2.* logL_A \
|
||||
-Mc * (np.log(np.diag(Lr)).sum()-np.log(np.diag(LSr)).sum()) -Mr * (np.log(np.diag(Lc)).sum()-np.log(np.diag(LSc)).sum()) \
|
||||
- np.square(LcInvMLrInvT).sum()/2. - tr_LrInvSrLrInvT * tr_LcInvScLcInvT/2. + Mr*Mc/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dKuu
|
||||
#======================================================================
|
||||
|
||||
tmp = beta* LcInvPsi2_cLcInvT.dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT).dot(LcInvMLrInvT.T) \
|
||||
+ beta* tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvPsi2_cLcInvT.dot(LcInvScLcInvT) \
|
||||
- beta* LcInvMLrInvT.dot(LrInvPsi1_rT).dot(Y.T).dot(LcInvPsi1_cT.T) \
|
||||
- beta/2. * tr_LrInvPsi2_rLrInvT* LcInvPsi2_cLcInvT - Mr/2.*np.eye(Mc) \
|
||||
+ tdot(LcInvMLrInvT)/2. + tr_LrInvSrLrInvT/2. * LcInvScLcInvT
|
||||
|
||||
dL_dKuu_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
dL_dKuu_c += dL_dKuu_c.T
|
||||
dL_dKuu_c *= 0.5
|
||||
|
||||
tmp = beta* LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT) \
|
||||
+ beta* tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvPsi2_rLrInvT.dot(LrInvSrLrInvT) \
|
||||
- beta* LrInvPsi1_rT.dot(Y.T).dot(LcInvPsi1_cT.T).dot(LcInvMLrInvT) \
|
||||
- beta/2. * tr_LcInvPsi2_cLcInvT * LrInvPsi2_rLrInvT - Mc/2.*np.eye(Mr) \
|
||||
+ tdot(LcInvMLrInvT.T)/2. + tr_LcInvScLcInvT/2. * LrInvSrLrInvT
|
||||
|
||||
dL_dKuu_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
dL_dKuu_r += dL_dKuu_r.T
|
||||
dL_dKuu_r *= 0.5
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dthetaL
|
||||
#======================================================================
|
||||
|
||||
dL_dthetaL = -D*N*beta/2. - logL_A*beta*beta/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dqU
|
||||
#======================================================================
|
||||
|
||||
tmp = -beta * LcInvPsi2_cLcInvT.dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT)\
|
||||
+ beta* LcInvPsi1_cT.dot(Y).dot(LrInvPsi1_rT.T) - LcInvMLrInvT
|
||||
|
||||
dL_dqU_mean = dtrtrs(Lc, dtrtrs(Lr, tmp.T, trans=1)[0].T, trans=1)[0]
|
||||
|
||||
LScInv = dtrtri(LSc)
|
||||
tmp = -beta/2.*tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvPsi2_cLcInvT -tr_LrInvSrLrInvT/2.*np.eye(Mc)
|
||||
dL_dqU_var_c = backsub_both_sides(Lc, tmp, 'left') + tdot(LScInv.T) * Mr/2.
|
||||
|
||||
LSrInv = dtrtri(LSr)
|
||||
tmp = -beta/2.*tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvPsi2_rLrInvT -tr_LcInvScLcInvT/2.*np.eye(Mr)
|
||||
dL_dqU_var_r = backsub_both_sides(Lr, tmp, 'left') + tdot(LSrInv.T) * Mc/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute the Posterior distribution of inducing points p(u|Y)
|
||||
#======================================================================
|
||||
|
||||
post = PosteriorMultioutput(LcInvMLrInvT=LcInvMLrInvT, LcInvScLcInvT=LcInvScLcInvT,
|
||||
LrInvSrLrInvT=LrInvSrLrInvT, Lr=Lr, Lc=Lc, kern_r=kern_r, Xr=Xr, Zr=Zr)
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dpsi
|
||||
#======================================================================
|
||||
|
||||
dL_dpsi0_r = - psi0_c * beta/2. * np.ones((D,))
|
||||
dL_dpsi0_c = - psi0_r * beta/2. * np.ones((N,))
|
||||
|
||||
dL_dpsi1_c = beta * dtrtrs(Lc, (Y.dot(LrInvPsi1_rT.T).dot(LcInvMLrInvT.T)).T, trans=1)[0].T
|
||||
dL_dpsi1_r = beta * dtrtrs(Lr, (Y.T.dot(LcInvPsi1_cT.T).dot(LcInvMLrInvT)).T, trans=1)[0].T
|
||||
|
||||
tmp = beta/2.*(-LcInvMLrInvT.dot(LrInvPsi2_rLrInvT).dot(LcInvMLrInvT.T) - tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvScLcInvT
|
||||
+tr_LrInvPsi2_rLrInvT *np.eye(Mc))
|
||||
dL_dpsi2_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
tmp = beta/2.*(-LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT) - tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvSrLrInvT
|
||||
+tr_LcInvPsi2_cLcInvT *np.eye(Mr))
|
||||
dL_dpsi2_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
|
||||
if not uncertain_inputs_r:
|
||||
dL_dpsi1_r += psi1_r.dot(dL_dpsi2_r+dL_dpsi2_r.T)
|
||||
if not uncertain_inputs_c:
|
||||
dL_dpsi1_c += psi1_c.dot(dL_dpsi2_c+dL_dpsi2_c.T)
|
||||
|
||||
grad_dict = {
|
||||
'dL_dthetaL':dL_dthetaL,
|
||||
'dL_dqU_mean':dL_dqU_mean,
|
||||
'dL_dqU_var_c':dL_dqU_var_c,
|
||||
'dL_dqU_var_r':dL_dqU_var_r,
|
||||
'dL_dKuu_c': dL_dKuu_c,
|
||||
'dL_dKuu_r': dL_dKuu_r,
|
||||
}
|
||||
|
||||
if uncertain_inputs_c:
|
||||
grad_dict['dL_dpsi0_c'] = dL_dpsi0_c
|
||||
grad_dict['dL_dpsi1_c'] = dL_dpsi1_c
|
||||
grad_dict['dL_dpsi2_c'] = dL_dpsi2_c
|
||||
else:
|
||||
grad_dict['dL_dKdiag_c'] = dL_dpsi0_c
|
||||
grad_dict['dL_dKfu_c'] = dL_dpsi1_c
|
||||
|
||||
if uncertain_inputs_r:
|
||||
grad_dict['dL_dpsi0_r'] = dL_dpsi0_r
|
||||
grad_dict['dL_dpsi1_r'] = dL_dpsi1_r
|
||||
grad_dict['dL_dpsi2_r'] = dL_dpsi2_r
|
||||
else:
|
||||
grad_dict['dL_dKdiag_r'] = dL_dpsi0_r
|
||||
grad_dict['dL_dKfu_r'] = dL_dpsi1_r
|
||||
|
||||
return post, logL, grad_dict
|
||||
|
||||
class PosteriorMultioutput(object):
|
||||
|
||||
def __init__(self,LcInvMLrInvT, LcInvScLcInvT, LrInvSrLrInvT, Lr, Lc, kern_r, Xr, Zr):
|
||||
self.LcInvMLrInvT = LcInvMLrInvT
|
||||
self.LcInvScLcInvT = LcInvScLcInvT
|
||||
self.LrInvSrLrInvT = LrInvSrLrInvT
|
||||
self.Lr = Lr
|
||||
self.Lc = Lc
|
||||
self.kern_r = kern_r
|
||||
self.Xr = Xr
|
||||
self.Zr = Zr
|
||||
|
||||
def _prepare(self):
|
||||
D, Mr, Mc = self.Xr.shape[0], self.Zr.shape[0], self.LcInvMLrInvT.shape[0]
|
||||
psi2_r_n = self.kern_r.psi2n(self.Zr, self.Xr)
|
||||
psi0_r = self.kern_r.psi0(self.Zr, self.Xr)
|
||||
psi1_r = self.kern_r.psi1(self.Zr, self.Xr)
|
||||
|
||||
LrInvPsi1_rT = dtrtrs(self.Lr, psi1_r.T)[0]
|
||||
self.woodbury_vector = self.LcInvMLrInvT.dot(LrInvPsi1_rT)
|
||||
|
||||
LrInvPsi2_r_nLrInvT = dtrtrs(self.Lr, np.swapaxes((dtrtrs(self.Lr, psi2_r_n.reshape(D*Mr,Mr).T)[0].T).reshape(D,Mr,Mr),1,2).reshape(D*Mr,Mr).T)[0].T.reshape(D,Mr,Mr)
|
||||
|
||||
tr_LrInvPsi2_r_nLrInvT = LrInvPsi2_r_nLrInvT.reshape(D,Mr*Mr).sum(1)
|
||||
tr_LrInvPsi2_r_nLrInvT_LrInvSrLrInvT = LrInvPsi2_r_nLrInvT.reshape(D,Mr*mr).dot(self.LrInvSrLrInvT.flat)
|
||||
|
||||
tmp = LrInvPsi2_r_nLrInvT - LrInvPsi1_rT.T[:,:,None]*LrInvPsi1_rT.T[:,None,:]
|
||||
tmp = np.swapaxes(tmp.reshape(D*Mr,Mr).dot(self.LcInvMLrInvT.T).reshape(D,Mr,Mc), 1,2).reshape(D*Mc,Mr).dot(self.LcInvMLrInvT.T).reshape(D,Mc,Mc)
|
||||
|
||||
def _raw_predict(self, kern, Xnew, pred_var, full_cov=False):
|
||||
|
||||
N = Xnew.shape[0]
|
||||
psi1_c = kern.K(Xnew, pred_var)
|
||||
psi0_c = kern.Kdiag(Xnew)
|
||||
LcInvPsi1_cT = dtrtrs(self.Lc, psi1_c.T)[0]
|
||||
|
||||
D, Mr, Mc = self.Xr.shape[0], self.Zr.shape[0], self.LcInvMLrInvT.shape[0]
|
||||
psi2_r_n = self.kern_r.psi2n(self.Zr, self.Xr)
|
||||
psi0_r = self.kern_r.psi0(self.Zr, self.Xr)
|
||||
psi1_r = self.kern_r.psi1(self.Zr, self.Xr)
|
||||
|
||||
LrInvPsi1_rT = dtrtrs(self.Lr, psi1_r.T)[0]
|
||||
woodbury_vector = self.LcInvMLrInvT.dot(LrInvPsi1_rT)
|
||||
|
||||
mu = np.dot(LcInvPsi1_cT.T, woodbury_vector)
|
||||
|
||||
LrInvPsi2_r_nLrInvT = dtrtrs(self.Lr, np.swapaxes((dtrtrs(self.Lr, psi2_r_n.reshape(D*Mr,Mr).T)[0].T).reshape(D,Mr,Mr),1,2).reshape(D*Mr,Mr).T)[0].T.reshape(D,Mr,Mr)
|
||||
|
||||
tr_LrInvPsi2_r_nLrInvT = np.diagonal(LrInvPsi2_r_nLrInvT,axis1=1,axis2=2).sum(1)
|
||||
tr_LrInvPsi2_r_nLrInvT_LrInvSrLrInvT = LrInvPsi2_r_nLrInvT.reshape(D,Mr*Mr).dot(self.LrInvSrLrInvT.flat)
|
||||
|
||||
tmp = LrInvPsi2_r_nLrInvT - LrInvPsi1_rT.T[:,:,None]*LrInvPsi1_rT.T[:,None,:]
|
||||
tmp = np.swapaxes(tmp.reshape(D*Mr,Mr).dot(self.LcInvMLrInvT.T).reshape(D,Mr,Mc), 1,2).reshape(D*Mc,Mr).dot(self.LcInvMLrInvT.T).reshape(D,Mc,Mc)
|
||||
|
||||
var1 = (tmp.reshape(D*Mc,Mc).dot(LcInvPsi1_cT).reshape(D,Mc,N)*LcInvPsi1_cT[None,:,:]).sum(1).T
|
||||
var2 = psi0_c[:,None]*psi0_r[None,:]
|
||||
var3 = tr_LrInvPsi2_r_nLrInvT[None,:]*np.square(LcInvPsi1_cT).sum(0)[:,None]
|
||||
var4 = tr_LrInvPsi2_r_nLrInvT_LrInvSrLrInvT[None,:]* (self.LcInvScLcInvT.dot(LcInvPsi1_cT)*LcInvPsi1_cT).sum(0)[:,None]
|
||||
var = var1+var2-var3+var4
|
||||
return mu, var
|
||||
|
|
@ -0,0 +1,306 @@
|
|||
#from .posterior import Posterior
|
||||
from GPy.util.linalg import jitchol, backsub_both_sides, tdot, dtrtrs, dtrtri,pdinv, dpotri
|
||||
from GPy.util import diag
|
||||
from GPy.core.parameterization.variational import VariationalPosterior
|
||||
import numpy as np
|
||||
from GPy.inference.latent_function_inference import LatentFunctionInference
|
||||
from GPy.inference.latent_function_inference.posterior import Posterior
|
||||
from .vardtc_svi_multiout import PosteriorMultioutput
|
||||
log_2_pi = np.log(2*np.pi)
|
||||
|
||||
|
||||
class VarDTC_SVI_Multiout_Miss(LatentFunctionInference):
|
||||
"""
|
||||
"""
|
||||
const_jitter = 1e-6
|
||||
|
||||
def get_trYYT(self, Y):
|
||||
return np.sum(np.square(Y))
|
||||
|
||||
def get_YYTfactor(self, Y):
|
||||
N, D = Y.shape
|
||||
if (N>=D):
|
||||
return Y.view(np.ndarray)
|
||||
else:
|
||||
return jitchol(tdot(Y))
|
||||
|
||||
def gatherPsiStat(self, kern, X, Z, uncertain_inputs):
|
||||
|
||||
if uncertain_inputs:
|
||||
psi0 = kern.psi0(Z, X)
|
||||
psi1 = kern.psi1(Z, X)
|
||||
psi2 = kern.psi2n(Z, X)
|
||||
else:
|
||||
psi0 = kern.Kdiag(X)
|
||||
psi1 = kern.K(X, Z)
|
||||
psi2 = psi1[:,:,None]*psi1[:,None,:]
|
||||
|
||||
return psi0, psi1, psi2
|
||||
|
||||
def _init_grad_dict(self, N, D, Mr, Mc):
|
||||
grad_dict = {
|
||||
'dL_dthetaL': np.zeros(D),
|
||||
'dL_dqU_mean': np.zeros((Mc,Mr)),
|
||||
'dL_dqU_var_c':np.zeros((Mc,Mc)),
|
||||
'dL_dqU_var_r':np.zeros((Mr,Mr)),
|
||||
'dL_dKuu_c': np.zeros((Mc,Mc)),
|
||||
'dL_dKuu_r': np.zeros((Mr,Mr)),
|
||||
'dL_dpsi0_c': np.zeros(N),
|
||||
'dL_dpsi1_c': np.zeros((N,Mc)),
|
||||
'dL_dpsi2_c': np.zeros((N,Mc,Mc)),
|
||||
'dL_dpsi0_r': np.zeros(D),
|
||||
'dL_dpsi1_r': np.zeros((D,Mr)),
|
||||
'dL_dpsi2_r': np.zeros((D,Mr,Mr)),
|
||||
}
|
||||
return grad_dict
|
||||
|
||||
def inference_d(self, d, beta, Y, indexD, grad_dict, mid_res, uncertain_inputs_r, uncertain_inputs_c, Mr, Mc):
|
||||
|
||||
idx_d = indexD==d
|
||||
Y = Y[idx_d]
|
||||
N, D = Y.shape[0], 1
|
||||
beta = beta[d]
|
||||
|
||||
psi0_r, psi1_r, psi2_r = mid_res['psi0_r'], mid_res['psi1_r'], mid_res['psi2_r']
|
||||
psi0_c, psi1_c, psi2_c = mid_res['psi0_c'], mid_res['psi1_c'], mid_res['psi2_c']
|
||||
psi0_r, psi1_r, psi2_r = psi0_r[d], psi1_r[d:d+1], psi2_r[d]
|
||||
psi0_c, psi1_c, psi2_c = psi0_c[idx_d].sum(), psi1_c[idx_d], psi2_c[idx_d].sum(0)
|
||||
|
||||
Lr = mid_res['Lr']
|
||||
Lc = mid_res['Lc']
|
||||
LcInvMLrInvT = mid_res['LcInvMLrInvT']
|
||||
LcInvScLcInvT = mid_res['LcInvScLcInvT']
|
||||
LrInvSrLrInvT = mid_res['LrInvSrLrInvT']
|
||||
|
||||
|
||||
LcInvPsi2_cLcInvT = backsub_both_sides(Lc, psi2_c,'right')
|
||||
LrInvPsi2_rLrInvT = backsub_both_sides(Lr, psi2_r,'right')
|
||||
LcInvPsi1_cT = dtrtrs(Lc, psi1_c.T)[0]
|
||||
LrInvPsi1_rT = dtrtrs(Lr, psi1_r.T)[0]
|
||||
|
||||
tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT = (LrInvPsi2_rLrInvT*LrInvSrLrInvT).sum()
|
||||
tr_LcInvPsi2_cLcInvT_LcInvScLcInvT = (LcInvPsi2_cLcInvT*LcInvScLcInvT).sum()
|
||||
tr_LrInvPsi2_rLrInvT = np.trace(LrInvPsi2_rLrInvT)
|
||||
tr_LcInvPsi2_cLcInvT = np.trace(LcInvPsi2_cLcInvT)
|
||||
|
||||
logL_A = - np.square(Y).sum() \
|
||||
- (LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT)*LrInvPsi2_rLrInvT).sum() \
|
||||
- tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT* tr_LcInvPsi2_cLcInvT_LcInvScLcInvT \
|
||||
+ 2 * (Y * LcInvPsi1_cT.T.dot(LcInvMLrInvT).dot(LrInvPsi1_rT)).sum() - psi0_c * psi0_r \
|
||||
+ tr_LrInvPsi2_rLrInvT * tr_LcInvPsi2_cLcInvT
|
||||
|
||||
logL = -N*D/2.*(np.log(2.*np.pi)-np.log(beta)) + beta/2.* logL_A
|
||||
|
||||
# ======= Gradients =====
|
||||
|
||||
tmp = beta* LcInvPsi2_cLcInvT.dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT).dot(LcInvMLrInvT.T) \
|
||||
+ beta* tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvPsi2_cLcInvT.dot(LcInvScLcInvT) \
|
||||
- beta* LcInvMLrInvT.dot(LrInvPsi1_rT).dot(Y.T).dot(LcInvPsi1_cT.T) \
|
||||
- beta/2. * tr_LrInvPsi2_rLrInvT* LcInvPsi2_cLcInvT
|
||||
|
||||
dL_dKuu_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
dL_dKuu_c += dL_dKuu_c.T
|
||||
dL_dKuu_c *= 0.5
|
||||
|
||||
tmp = beta* LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT) \
|
||||
+ beta* tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvPsi2_rLrInvT.dot(LrInvSrLrInvT) \
|
||||
- beta* LrInvPsi1_rT.dot(Y.T).dot(LcInvPsi1_cT.T).dot(LcInvMLrInvT) \
|
||||
- beta/2. * tr_LcInvPsi2_cLcInvT * LrInvPsi2_rLrInvT
|
||||
|
||||
dL_dKuu_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
dL_dKuu_r += dL_dKuu_r.T
|
||||
dL_dKuu_r *= 0.5
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dthetaL
|
||||
#======================================================================
|
||||
|
||||
dL_dthetaL = -D*N*beta/2. - logL_A*beta*beta/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dqU
|
||||
#======================================================================
|
||||
|
||||
tmp = -beta * LcInvPsi2_cLcInvT.dot(LcInvMLrInvT).dot(LrInvPsi2_rLrInvT)\
|
||||
+ beta* LcInvPsi1_cT.dot(Y).dot(LrInvPsi1_rT.T)
|
||||
|
||||
dL_dqU_mean = dtrtrs(Lc, dtrtrs(Lr, tmp.T, trans=1)[0].T, trans=1)[0]
|
||||
|
||||
tmp = -beta/2.*tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvPsi2_cLcInvT
|
||||
dL_dqU_var_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
|
||||
tmp = -beta/2.*tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvPsi2_rLrInvT
|
||||
dL_dqU_var_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dpsi
|
||||
#======================================================================
|
||||
|
||||
dL_dpsi0_r = - psi0_c * beta/2. * np.ones((D,))
|
||||
dL_dpsi0_c = - psi0_r * beta/2. * np.ones((N,))
|
||||
|
||||
dL_dpsi1_c = beta * dtrtrs(Lc, (Y.dot(LrInvPsi1_rT.T).dot(LcInvMLrInvT.T)).T, trans=1)[0].T
|
||||
dL_dpsi1_r = beta * dtrtrs(Lr, (Y.T.dot(LcInvPsi1_cT.T).dot(LcInvMLrInvT)).T, trans=1)[0].T
|
||||
|
||||
tmp = beta/2.*(-LcInvMLrInvT.dot(LrInvPsi2_rLrInvT).dot(LcInvMLrInvT.T) - tr_LrInvPsi2_rLrInvT_LrInvSrLrInvT * LcInvScLcInvT
|
||||
+tr_LrInvPsi2_rLrInvT *np.eye(Mc))
|
||||
dL_dpsi2_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
tmp = beta/2.*(-LcInvMLrInvT.T.dot(LcInvPsi2_cLcInvT).dot(LcInvMLrInvT) - tr_LcInvPsi2_cLcInvT_LcInvScLcInvT * LrInvSrLrInvT
|
||||
+tr_LcInvPsi2_cLcInvT *np.eye(Mr))
|
||||
dL_dpsi2_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
|
||||
grad_dict['dL_dthetaL'][d:d+1] = dL_dthetaL
|
||||
grad_dict['dL_dqU_mean'] += dL_dqU_mean
|
||||
grad_dict['dL_dqU_var_c'] += dL_dqU_var_c
|
||||
grad_dict['dL_dqU_var_r'] += dL_dqU_var_r
|
||||
grad_dict['dL_dKuu_c'] += dL_dKuu_c
|
||||
grad_dict['dL_dKuu_r'] += dL_dKuu_r
|
||||
|
||||
# if not uncertain_inputs_r:
|
||||
# dL_dpsi1_r += (dL_dpsi2_r * psi1_r[:,:,None]).sum(1) + (dL_dpsi2_r * psi1_r[:,None,:]).sum(2)
|
||||
# if not uncertain_inputs_c:
|
||||
# dL_dpsi1_c += (dL_dpsi2_c * psi1_c[:,:,None]).sum(1) + (dL_dpsi2_c * psi1_c[:,None,:]).sum(2)
|
||||
|
||||
if not uncertain_inputs_r:
|
||||
dL_dpsi1_r += psi1_r.dot(dL_dpsi2_r+dL_dpsi2_r.T)
|
||||
if not uncertain_inputs_c:
|
||||
dL_dpsi1_c += psi1_c.dot(dL_dpsi2_c+dL_dpsi2_c.T)
|
||||
|
||||
grad_dict['dL_dpsi0_c'][idx_d] += dL_dpsi0_c
|
||||
grad_dict['dL_dpsi1_c'][idx_d] += dL_dpsi1_c
|
||||
grad_dict['dL_dpsi2_c'][idx_d] += dL_dpsi2_c
|
||||
|
||||
grad_dict['dL_dpsi0_r'][d:d+1] += dL_dpsi0_r
|
||||
grad_dict['dL_dpsi1_r'][d:d+1] += dL_dpsi1_r
|
||||
grad_dict['dL_dpsi2_r'][d] += dL_dpsi2_r
|
||||
|
||||
|
||||
return logL
|
||||
|
||||
|
||||
def inference(self, kern_r, kern_c, Xr, Xc, Zr, Zc, likelihood, Y, qU_mean ,qU_var_r, qU_var_c, indexD, output_dim):
|
||||
"""
|
||||
The SVI-VarDTC inference
|
||||
"""
|
||||
|
||||
N, D, Mr, Mc, Qr, Qc = Y.shape[0], output_dim,Zr.shape[0], Zc.shape[0], Zr.shape[1], Zc.shape[1]
|
||||
|
||||
uncertain_inputs_r = isinstance(Xr, VariationalPosterior)
|
||||
uncertain_inputs_c = isinstance(Xc, VariationalPosterior)
|
||||
uncertain_outputs = isinstance(Y, VariationalPosterior)
|
||||
|
||||
grad_dict = self._init_grad_dict(N,D,Mr,Mc)
|
||||
|
||||
beta = 1./likelihood.variance
|
||||
if len(beta)==1:
|
||||
beta = np.zeros(D)+beta
|
||||
|
||||
psi0_r, psi1_r, psi2_r = self.gatherPsiStat(kern_r, Xr, Zr, uncertain_inputs_r)
|
||||
psi0_c, psi1_c, psi2_c = self.gatherPsiStat(kern_c, Xc, Zc, uncertain_inputs_c)
|
||||
|
||||
#======================================================================
|
||||
# Compute Common Components
|
||||
#======================================================================
|
||||
|
||||
Kuu_r = kern_r.K(Zr).copy()
|
||||
diag.add(Kuu_r, self.const_jitter)
|
||||
Lr = jitchol(Kuu_r)
|
||||
|
||||
Kuu_c = kern_c.K(Zc).copy()
|
||||
diag.add(Kuu_c, self.const_jitter)
|
||||
Lc = jitchol(Kuu_c)
|
||||
|
||||
mu, Sr, Sc = qU_mean, qU_var_r, qU_var_c
|
||||
LSr = jitchol(Sr)
|
||||
LSc = jitchol(Sc)
|
||||
|
||||
LcInvMLrInvT = dtrtrs(Lc,dtrtrs(Lr,mu.T)[0].T)[0]
|
||||
LcInvLSc = dtrtrs(Lc, LSc)[0]
|
||||
LrInvLSr = dtrtrs(Lr, LSr)[0]
|
||||
LcInvScLcInvT = tdot(LcInvLSc)
|
||||
LrInvSrLrInvT = tdot(LrInvLSr)
|
||||
tr_LrInvSrLrInvT = np.square(LrInvLSr).sum()
|
||||
tr_LcInvScLcInvT = np.square(LcInvLSc).sum()
|
||||
|
||||
mid_res = {
|
||||
'psi0_r': psi0_r,
|
||||
'psi1_r': psi1_r,
|
||||
'psi2_r': psi2_r,
|
||||
'psi0_c': psi0_c,
|
||||
'psi1_c': psi1_c,
|
||||
'psi2_c': psi2_c,
|
||||
'Lr':Lr,
|
||||
'Lc':Lc,
|
||||
'LcInvMLrInvT': LcInvMLrInvT,
|
||||
'LcInvScLcInvT': LcInvScLcInvT,
|
||||
'LrInvSrLrInvT': LrInvSrLrInvT,
|
||||
}
|
||||
|
||||
#======================================================================
|
||||
# Compute log-likelihood
|
||||
#======================================================================
|
||||
|
||||
logL = 0.
|
||||
for d in range(D):
|
||||
logL += self.inference_d(d, beta, Y, indexD, grad_dict, mid_res, uncertain_inputs_r, uncertain_inputs_c, Mr, Mc)
|
||||
|
||||
logL += -Mc * (np.log(np.diag(Lr)).sum()-np.log(np.diag(LSr)).sum()) -Mr * (np.log(np.diag(Lc)).sum()-np.log(np.diag(LSc)).sum()) \
|
||||
- np.square(LcInvMLrInvT).sum()/2. - tr_LrInvSrLrInvT * tr_LcInvScLcInvT/2. + Mr*Mc/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dKuu
|
||||
#======================================================================
|
||||
|
||||
tmp = tdot(LcInvMLrInvT)/2. + tr_LrInvSrLrInvT/2. * LcInvScLcInvT - Mr/2.*np.eye(Mc)
|
||||
|
||||
dL_dKuu_c = backsub_both_sides(Lc, tmp, 'left')
|
||||
dL_dKuu_c += dL_dKuu_c.T
|
||||
dL_dKuu_c *= 0.5
|
||||
|
||||
tmp = tdot(LcInvMLrInvT.T)/2. + tr_LcInvScLcInvT/2. * LrInvSrLrInvT - Mc/2.*np.eye(Mr)
|
||||
|
||||
dL_dKuu_r = backsub_both_sides(Lr, tmp, 'left')
|
||||
dL_dKuu_r += dL_dKuu_r.T
|
||||
dL_dKuu_r *= 0.5
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dqU
|
||||
#======================================================================
|
||||
|
||||
tmp = - LcInvMLrInvT
|
||||
dL_dqU_mean = dtrtrs(Lc, dtrtrs(Lr, tmp.T, trans=1)[0].T, trans=1)[0]
|
||||
|
||||
LScInv = dtrtri(LSc)
|
||||
tmp = -tr_LrInvSrLrInvT/2.*np.eye(Mc)
|
||||
dL_dqU_var_c = backsub_both_sides(Lc, tmp, 'left') + tdot(LScInv.T) * Mr/2.
|
||||
|
||||
LSrInv = dtrtri(LSr)
|
||||
tmp = -tr_LcInvScLcInvT/2.*np.eye(Mr)
|
||||
dL_dqU_var_r = backsub_both_sides(Lr, tmp, 'left') + tdot(LSrInv.T) * Mc/2.
|
||||
|
||||
#======================================================================
|
||||
# Compute the Posterior distribution of inducing points p(u|Y)
|
||||
#======================================================================
|
||||
|
||||
post = PosteriorMultioutput(LcInvMLrInvT=LcInvMLrInvT, LcInvScLcInvT=LcInvScLcInvT,
|
||||
LrInvSrLrInvT=LrInvSrLrInvT, Lr=Lr, Lc=Lc, kern_r=kern_r, Xr=Xr, Zr=Zr)
|
||||
|
||||
#======================================================================
|
||||
# Compute dL_dpsi
|
||||
#======================================================================
|
||||
|
||||
grad_dict['dL_dqU_mean'] += dL_dqU_mean
|
||||
grad_dict['dL_dqU_var_c'] += dL_dqU_var_c
|
||||
grad_dict['dL_dqU_var_r'] += dL_dqU_var_r
|
||||
grad_dict['dL_dKuu_c'] += dL_dKuu_c
|
||||
grad_dict['dL_dKuu_r'] += dL_dKuu_r
|
||||
|
||||
if not uncertain_inputs_c:
|
||||
grad_dict['dL_dKdiag_c'] = grad_dict['dL_dpsi0_c']
|
||||
grad_dict['dL_dKfu_c'] = grad_dict['dL_dpsi1_c']
|
||||
|
||||
if not uncertain_inputs_r:
|
||||
grad_dict['dL_dKdiag_r'] = grad_dict['dL_dpsi0_r']
|
||||
grad_dict['dL_dKfu_r'] = grad_dict['dL_dpsi1_r']
|
||||
|
||||
return post, logL, grad_dict
|
||||
Loading…
Add table
Add a link
Reference in a new issue