From 5cc17e87542da0ec1b41d3c159caeb22ac493cd2 Mon Sep 17 00:00:00 2001 From: Zhenwen Dai Date: Sun, 28 Jun 2015 21:33:57 +0100 Subject: [PATCH 1/2] some correction for ibp ssgplvm --- .../latent_function_inference/inferenceX.py | 24 ++++++++++++------- GPy/kern/_src/rbf.py | 2 +- GPy/models/bayesian_gplvm_minibatch.py | 3 --- GPy/plotting/matplot_dep/visualize.py | 20 +++++++++++----- 4 files changed, 30 insertions(+), 19 deletions(-) diff --git a/GPy/inference/latent_function_inference/inferenceX.py b/GPy/inference/latent_function_inference/inferenceX.py index f68f17cb..a8ed2d09 100644 --- a/GPy/inference/latent_function_inference/inferenceX.py +++ b/GPy/inference/latent_function_inference/inferenceX.py @@ -45,17 +45,23 @@ class InferenceX(Model): super(InferenceX, self).__init__(name) self.likelihood = model.likelihood.copy() self.kern = model.kern.copy() - if model.kern.useGPU: - from ...models import SSGPLVM - if isinstance(model, SSGPLVM): - self.kern.GPU_SSRBF(True) - else: - self.kern.GPU(True) +# if model.kern.useGPU: +# from ...models import SSGPLVM +# if isinstance(model, SSGPLVM): +# self.kern.GPU_SSRBF(True) +# else: +# self.kern.GPU(True) from copy import deepcopy self.posterior = deepcopy(model.posterior) if hasattr(model, 'variational_prior'): self.uncertain_input = True - self.variational_prior = model.variational_prior.copy() + from ...models.ss_gplvm import IBPPrior + from ...models.ss_mrd import IBPPrior_SSMRD + if isinstance(model.variational_prior, IBPPrior) or isinstance(model.variational_prior, IBPPrior_SSMRD): + from ...core.parameterization.variational import SpikeAndSlabPrior + self.variational_prior = SpikeAndSlabPrior(pi=05,learnPi=False, group_spike=False) + else: + self.variational_prior = model.variational_prior.copy() else: self.uncertain_input = False if hasattr(model, 'inducing_inputs'): @@ -147,9 +153,9 @@ class InferenceX(Model): from ...core.parameterization.variational import SpikeAndSlabPrior if isinstance(self.variational_prior, SpikeAndSlabPrior): # Update Log-likelihood - KL_div = self.variational_prior.KL_divergence(self.X, N=self.Y.shape[0]) + KL_div = self.variational_prior.KL_divergence(self.X) # update for the KL divergence - self.variational_prior.update_gradients_KL(self.X, N=self.Y.shape[0]) + self.variational_prior.update_gradients_KL(self.X) else: # Update Log-likelihood KL_div = self.variational_prior.KL_divergence(self.X) diff --git a/GPy/kern/_src/rbf.py b/GPy/kern/_src/rbf.py index c6998370..73f2d0a4 100644 --- a/GPy/kern/_src/rbf.py +++ b/GPy/kern/_src/rbf.py @@ -20,7 +20,6 @@ class RBF(Stationary): _support_GPU = True def __init__(self, input_dim, variance=1., lengthscale=None, ARD=False, active_dims=None, name='rbf', useGPU=False): super(RBF, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, useGPU=useGPU) - self.psicomp = PSICOMP_RBF() if self.useGPU: self.psicomp = PSICOMP_RBF_GPU() else: @@ -36,6 +35,7 @@ class RBF(Stationary): dc = super(RBF, self).__getstate__() if self.useGPU: dc['psicomp'] = PSICOMP_RBF() + dc['useGPU'] = False return dc def __setstate__(self, state): diff --git a/GPy/models/bayesian_gplvm_minibatch.py b/GPy/models/bayesian_gplvm_minibatch.py index 71f69eb2..7a7bb0e8 100644 --- a/GPy/models/bayesian_gplvm_minibatch.py +++ b/GPy/models/bayesian_gplvm_minibatch.py @@ -64,9 +64,6 @@ class BayesianGPLVMMiniBatch(SparseGPMiniBatch): self.logger.debug("creating inference_method var_dtc") inference_method = VarDTC(limit=1 if not missing_data else Y.shape[1]) - if kernel.useGPU and isinstance(inference_method, VarDTC_GPU): - kernel.psicomp.GPU_direct = True - super(BayesianGPLVMMiniBatch,self).__init__(X, Y, Z, kernel, likelihood=likelihood, name=name, inference_method=inference_method, normalizer=normalizer, diff --git a/GPy/plotting/matplot_dep/visualize.py b/GPy/plotting/matplot_dep/visualize.py index 6903c2d2..b17900db 100644 --- a/GPy/plotting/matplot_dep/visualize.py +++ b/GPy/plotting/matplot_dep/visualize.py @@ -451,7 +451,7 @@ class mocap_data_show(matplotlib_show): self.initialize_axes_modify() self.draw_vertices() self.initialize_axes() - self.finalize_axes_modify() + #self.finalize_axes_modify() self.draw_edges() self.axes.figure.canvas.draw() @@ -470,12 +470,20 @@ class mocap_data_show(matplotlib_show): self.line_handle[0].remove() def finalize_axes(self): - self.axes.set_xlim(self.x_lim) - self.axes.set_ylim(self.y_lim) - self.axes.set_zlim(self.z_lim) - self.axes.auto_scale_xyz([-1., 1.], [-1., 1.], [-1., 1.]) +# self.axes.set_xlim(self.x_lim) +# self.axes.set_ylim(self.y_lim) +# self.axes.set_zlim(self.z_lim) +# self.axes.auto_scale_xyz([-1., 1.], [-1., 1.], [-1., 1.]) -# self.axes.set_aspect('equal') + extents = np.array([getattr(self.axes, 'get_{}lim'.format(dim))() for dim in 'xyz']) + sz = extents[:,1] - extents[:,0] + centers = np.mean(extents, axis=1) + maxsize = max(abs(sz)) + r = maxsize/2 + for ctr, dim in zip(centers, 'xyz'): + getattr(self.axes, 'set_{}lim'.format(dim))(ctr - r, ctr + r) + +# self.axes.set_aspect('equal') # self.axes.autoscale(enable=False) def finalize_axes_modify(self): From efa65c864e19e4587e57866b929c0b83608b2c44 Mon Sep 17 00:00:00 2001 From: James Hensman Date: Thu, 16 Jul 2015 15:36:17 +0100 Subject: [PATCH 2/2] generalized the variatinoal Gaussian approximatino revisited code for any likelihood --- GPy/models/gp_var_gauss.py | 54 ++++++++++++++------------------------ 1 file changed, 19 insertions(+), 35 deletions(-) diff --git a/GPy/models/gp_var_gauss.py b/GPy/models/gp_var_gauss.py index cd688360..ccaab305 100644 --- a/GPy/models/gp_var_gauss.py +++ b/GPy/models/gp_var_gauss.py @@ -15,7 +15,7 @@ log_2_pi = np.log(2*np.pi) class GPVariationalGaussianApproximation(Model): """ - The Variational Gaussian Approximation revisited implementation for regression + The Variational Gaussian Approximation revisited @article{Opper:2009, title = {The Variational Gaussian Approximation Revisited}, @@ -25,44 +25,27 @@ class GPVariationalGaussianApproximation(Model): pages = {786--792}, } """ - def __init__(self, X, Y, kernel=None): + def __init__(self, X, Y, kernel, likelihood,Y_metadata=None): Model.__init__(self,'Variational GP classification') # accept the construction arguments self.X = ObsAr(X) - if kernel is None: - kernel = kern.RBF(X.shape[1]) + kern.White(X.shape[1], 0.01) - self.kern = kernel - self.link_parameter(self.kern) + self.Y = Y self.num_data, self.input_dim = self.X.shape + self.Y_metadata = Y_metadata - self.alpha = Param('alpha', np.zeros(self.num_data)) + self.kern = kernel + self.likelihood = likelihood + self.link_parameter(self.kern) + self.link_parameter(self.likelihood) + + self.alpha = Param('alpha', np.zeros((self.num_data,1))) # only one latent fn for now. self.beta = Param('beta', np.ones(self.num_data)) self.link_parameter(self.alpha) self.link_parameter(self.beta) - self.gh_x, self.gh_w = np.polynomial.hermite.hermgauss(20) - self.Ysign = np.where(Y==1, 1, -1).flatten() - def log_likelihood(self): - """ - Marginal log likelihood evaluation - """ return self._log_lik - def likelihood_quadrature(self, m, v): - """ - Perform Gauss-Hermite quadrature over the log of the likelihood, with a fixed weight - """ - # assume probit for now. - X = self.gh_x[None, :]*np.sqrt(2.*v[:, None]) + (m*self.Ysign)[:, None] - p = stats.norm.cdf(X) - N = stats.norm.pdf(X) - F = np.log(p).dot(self.gh_w) - NoverP = N/p - dF_dm = (NoverP*self.Ysign[:,None]).dot(self.gh_w) - dF_dv = -0.5*(NoverP**2 + NoverP*X).dot(self.gh_w) - return F, dF_dm, dF_dv - def parameters_changed(self): K = self.kern.K(self.X) m = K.dot(self.alpha) @@ -71,13 +54,14 @@ class GPVariationalGaussianApproximation(Model): A = np.eye(self.num_data) + BKB Ai, LA, _, Alogdet = pdinv(A) Sigma = np.diag(self.beta**-2) - Ai/self.beta[:, None]/self.beta[None, :] # posterior coavairance: need full matrix for gradients - var = np.diag(Sigma) + var = np.diag(Sigma).reshape(-1,1) - F, dF_dm, dF_dv = self.likelihood_quadrature(m, var) + F, dF_dm, dF_dv, dF_dthetaL = self.likelihood.variational_expectations(self.Y, m, var, Y_metadata=self.Y_metadata) + self.likelihood.gradient = dF_dthetaL.sum(1).sum(1) dF_da = np.dot(K, dF_dm) SigmaB = Sigma*self.beta - dF_db = -np.diag(Sigma.dot(np.diag(dF_dv)).dot(SigmaB))*2 - KL = 0.5*(Alogdet + np.trace(Ai) - self.num_data + m.dot(self.alpha)) + dF_db = -np.diag(Sigma.dot(np.diag(dF_dv.flatten())).dot(SigmaB))*2 + KL = 0.5*(Alogdet + np.trace(Ai) - self.num_data + np.sum(m*self.alpha)) dKL_da = m A_A2 = Ai - Ai.dot(Ai) dKL_db = np.diag(np.dot(KB.T, A_A2)) @@ -86,12 +70,12 @@ class GPVariationalGaussianApproximation(Model): self.beta.gradient = dF_db - dKL_db # K-gradients - dKL_dK = 0.5*(self.alpha[None, :]*self.alpha[:, None] + self.beta[:, None]*self.beta[None, :]*A_A2) + dKL_dK = 0.5*(self.alpha*self.alpha.T + self.beta[:, None]*self.beta[None, :]*A_A2) tmp = Ai*self.beta[:, None]/self.beta[None, :] - dF_dK = self.alpha[:, None]*dF_dm[None, :] + np.dot(tmp*dF_dv, tmp.T) + dF_dK = self.alpha*dF_dm.T + np.dot(tmp*dF_dv, tmp.T) self.kern.update_gradients_full(dF_dK - dKL_dK, self.X) - def predict(self, Xnew): + def _raw_predict(self, Xnew): """ Predict the function(s) at the new point(s) Xnew. @@ -105,4 +89,4 @@ class GPVariationalGaussianApproximation(Model): Kxx = self.kern.Kdiag(Xnew) var = Kxx - np.sum(WiKux*Kux, 0) - return 0.5*(1+erf(mu/np.sqrt(2.*(var+1)))) + return mu, var.reshape(-1,1)