restructure rbf kernel

GPy/kern/_src/psi_comp/__init__.py

@@ -2,6 +2,10 @@
 # Licensed under the BSD 3-clause license (see LICENSE.txt)
 
 from ....core.parameterization.parameter_core import Pickleable
+from GPy.util.caching import Cache_this
+from ....core.parameterization import variational
+import rbf_psi_comp
+import ssrbf_psi_comp
 
 class PSICOMP(Pickleable):
 
@@ -17,3 +21,22 @@ class PSICOMP(Pickleable):
         """
         pass
 
+class PSICOMP_RBF(Pickleable):
+
+    @Cache_this(limit=1, ignore_args=(0,))
+    def psicomputations(self, variance, lengthscale, Z, variational_posterior):
+        if isinstance(variational_posterior, variational.NormalPosterior):
+            return rbf_psi_comp.psicomputations(variance, lengthscale, Z, variational_posterior)
+        elif isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
+            return ssrbf_psi_comp.psicomputations(variance, lengthscale, Z, variational_posterior)
+        else:
+            raise ValueError, "unknown distriubtion received for psi-statistics"
+                
+    @Cache_this(limit=1, ignore_args=(0,1,2,3))
+    def psiDerivativecomputations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior):
+        if isinstance(variational_posterior, variational.NormalPosterior):
+            return rbf_psi_comp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior)
+        elif isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
+            return ssrbf_psi_comp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior)
+        else:
+            raise ValueError, "unknown distriubtion received for psi-statistics"

GPy/kern/_src/psi_comp/rbf_psi_comp.py

@@ -3,16 +3,9 @@ The module for psi-statistics for RBF kernel
 """
 
 import numpy as np
-from . import PSICOMP
+from GPy.util.caching import Cacher
-from GPy.util.caching import Cache_this
-from ....util.misc import param_to_array
-from scipy import weave
-from ....util.config import *
 
-class PSICOMP_RBF(PSICOMP):
+def psicomputations(variance, lengthscale, Z, variational_posterior):
-    
-    @Cache_this(limit=1, ignore_args=(0,))
-    def psicomputations(self, variance, lengthscale, Z, variational_posterior):
     """
     Z - MxQ
     mu - NxQ
@@ -27,12 +20,11 @@ class PSICOMP_RBF(PSICOMP):
     
     psi0 = np.empty(mu.shape[0])
     psi0[:] = variance
-        psi1 = self._psi1computations(variance, lengthscale, Z, mu, S)
+    psi1 = _psi1computations(variance, lengthscale, Z, mu, S)
-        psi2 = self._psi2computations(variance, lengthscale, Z, mu, S).sum(axis=0)
+    psi2 = _psi2computations(variance, lengthscale, Z, mu, S).sum(axis=0)
     return psi0, psi1, psi2
 
-    @Cache_this(limit=1, ignore_args=(0,))
+def __psi1computations(variance, lengthscale, Z, mu, S):
-    def _psi1computations(self, variance, lengthscale, Z, mu, S):
     """
     Z - MxQ
     mu - NxQ
@@ -52,8 +44,7 @@ class PSICOMP_RBF(PSICOMP):
         
     return _psi1
 
-    @Cache_this(limit=1, ignore_args=(0,))
+def __psi2computations(variance, lengthscale, Z, mu, S):
-    def _psi2computations(self, variance, lengthscale, Z, mu, S):
     """
     Z - MxQ
     mu - NxQ
@@ -76,12 +67,11 @@ class PSICOMP_RBF(PSICOMP):
 
     return _psi2
 
-    @Cache_this(limit=1, ignore_args=(0,1,2,3))
+def psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior):
-    def psiDerivativecomputations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior):
     ARD = (len(lengthscale)!=1)
     
-        dvar_psi1, dl_psi1, dZ_psi1, dmu_psi1, dS_psi1 = self._psi1compDer(dL_dpsi1, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance)
+    dvar_psi1, dl_psi1, dZ_psi1, dmu_psi1, dS_psi1 = _psi1compDer(dL_dpsi1, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance)
-        dvar_psi2, dl_psi2, dZ_psi2, dmu_psi2, dS_psi2 = self._psi2compDer(dL_dpsi2, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance)
+    dvar_psi2, dl_psi2, dZ_psi2, dmu_psi2, dS_psi2 = _psi2compDer(dL_dpsi2, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance)
 
     dL_dvar = np.sum(dL_dpsi0) + dvar_psi1 + dvar_psi2
     
@@ -95,7 +85,7 @@ class PSICOMP_RBF(PSICOMP):
     
     return dL_dvar, dL_dlengscale, dL_dZ, dL_dmu, dL_dS
 
-    def _psi1compDer(self, dL_dpsi1, variance, lengthscale, Z, mu, S):
+def _psi1compDer(dL_dpsi1, variance, lengthscale, Z, mu, S):
     """
     dL_dpsi1 - NxM
     Z - MxQ
@@ -114,7 +104,7 @@ class PSICOMP_RBF(PSICOMP):
     
     lengthscale2 = np.square(lengthscale)
     
-        _psi1 = self._psi1computations(variance, lengthscale, Z, mu, S)
+    _psi1 = _psi1computations(variance, lengthscale, Z, mu, S)
     Lpsi1 = dL_dpsi1*_psi1
     Zmu = Z[None,:,:]-mu[:,None,:] # NxMxQ
     denom = 1./(S+lengthscale2)
@@ -127,7 +117,7 @@ class PSICOMP_RBF(PSICOMP):
     
     return _dL_dvar, _dL_dl, _dL_dZ, _dL_dmu, _dL_dS
 
-    def _psi2compDer(self, dL_dpsi2, variance, lengthscale, Z, mu, S):
+def _psi2compDer(dL_dpsi2, variance, lengthscale, Z, mu, S):
     """
     Z - MxQ
     mu - NxQ
@@ -148,7 +138,7 @@ class PSICOMP_RBF(PSICOMP):
     denom = 1./(2*S+lengthscale2)
     denom2 = np.square(denom)
 
-        _psi2 = self._psi2computations(variance, lengthscale, Z, mu, S) # NxMxM
+    _psi2 = _psi2computations(variance, lengthscale, Z, mu, S) # NxMxM
     
     Lpsi2 = dL_dpsi2[None,:,:]*_psi2
     Lpsi2sum = np.einsum('nmo->n',Lpsi2) #N
@@ -168,3 +158,5 @@ class PSICOMP_RBF(PSICOMP):
 
     return _dL_dvar, _dL_dl, _dL_dZ, _dL_dmu, _dL_dS
     
+_psi1computations = Cacher(__psi1computations, limit=1)
+_psi2computations = Cacher(__psi2computations, limit=1)

GPy/kern/_src/psi_comp/ssrbf_psi_comp.py

@@ -6,13 +6,8 @@ The package for the psi statistics computation
 """
 
 import numpy as np
-from . import PSICOMP
-from GPy.util.caching import Cache_this
 
-class PSICOMP_SSRBF(PSICOMP):
+def psicomputations(variance, lengthscale, Z, variational_posterior):
-    
-    @Cache_this(limit=1, ignore_args=(0,))
-    def psicomputations(self, variance, lengthscale, Z, variational_posterior):
     """
     Z - MxQ
     mu - NxQ
@@ -28,11 +23,11 @@ class PSICOMP_SSRBF(PSICOMP):
     
     psi0 = np.empty(mu.shape[0])
     psi0[:] = variance
-        psi1 = self._psi1computations(variance, lengthscale, Z, mu, S, gamma)
+    psi1 = _psi1computations(variance, lengthscale, Z, mu, S, gamma)
-        psi2 = self._psi2computations(variance, lengthscale, Z, mu, S, gamma)
+    psi2 = _psi2computations(variance, lengthscale, Z, mu, S, gamma)
     return psi0, psi1, psi2
 
-    def _psi1computations(self, variance, lengthscale, Z, mu, S, gamma):
+def _psi1computations(variance, lengthscale, Z, mu, S, gamma):
     """
     Z - MxQ
     mu - NxQ
@@ -60,7 +55,7 @@ class PSICOMP_SSRBF(PSICOMP):
 
     return _psi1
 
-    def _psi2computations(self, variance, lengthscale, Z, mu, S, gamma):
+def _psi2computations(variance, lengthscale, Z, mu, S, gamma):
     """
     Z - MxQ
     mu - NxQ
@@ -93,12 +88,11 @@ class PSICOMP_SSRBF(PSICOMP):
 
     return _psi2
 
-    @Cache_this(limit=1, ignore_args=(0,1,2,3))
+def psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior):
-    def psiDerivativecomputations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, variance, lengthscale, Z, variational_posterior):
     ARD = (len(lengthscale)!=1)
     
-        dvar_psi1, dl_psi1, dZ_psi1, dmu_psi1, dS_psi1, dgamma_psi1 = self._psi1compDer(dL_dpsi1, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)
+    dvar_psi1, dl_psi1, dZ_psi1, dmu_psi1, dS_psi1, dgamma_psi1 = _psi1compDer(dL_dpsi1, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)
-        dvar_psi2, dl_psi2, dZ_psi2, dmu_psi2, dS_psi2, dgamma_psi2 = self._psi2compDer(dL_dpsi2, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)
+    dvar_psi2, dl_psi2, dZ_psi2, dmu_psi2, dS_psi2, dgamma_psi2 = _psi2compDer(dL_dpsi2, variance, lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)
 
     dL_dvar = np.sum(dL_dpsi0) + dvar_psi1 + dvar_psi2
     
@@ -113,7 +107,7 @@ class PSICOMP_SSRBF(PSICOMP):
     
     return dL_dvar, dL_dlengscale, dL_dZ, dL_dmu, dL_dS, dL_dgamma
 
-    def _psi1compDer(self, dL_dpsi1, variance, lengthscale, Z, mu, S, gamma):
+def _psi1compDer(dL_dpsi1, variance, lengthscale, Z, mu, S, gamma):
     """
     dL_dpsi1 - NxM
     Z - MxQ
@@ -156,7 +150,7 @@ class PSICOMP_SSRBF(PSICOMP):
 
     return _dL_dvariance, _dL_dlengthscale, _dL_dZ, _dL_dmu, _dL_dS, _dL_dgamma 
 
-    def _psi2compDer(self, dL_dpsi2, variance, lengthscale, Z, mu, S, gamma):
+def _psi2compDer(dL_dpsi2, variance, lengthscale, Z, mu, S, gamma):
     """
     Z - MxQ
     mu - NxQ

GPy/kern/_src/rbf.py

@@ -8,7 +8,7 @@ from ...util.misc import param_to_array
 from stationary import Stationary
 from GPy.util.caching import Cache_this
 from ...core.parameterization import variational
-from psi_comp import ssrbf_psi_comp,ssrbf_psi_gpucomp,rbf_psi_comp
+from psi_comp import PSICOMP_RBF
 from ...util.config import *
 
 class RBF(Stationary):
@@ -25,13 +25,7 @@ class RBF(Stationary):
         super(RBF, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, useGPU=useGPU)
         self.weave_options = {}
         self.group_spike_prob = False
-        self.psicomp = rbf_psi_comp.PSICOMP_RBF()
+        self.psicomp = PSICOMP_RBF()
-        
-    def set_for_SpikeAndSlab(self):
-        if self.useGPU:
-            self.psicomp = ssrbf_psi_gpucomp.PSICOMP_SSRBF()
-        else:
-            self.psicomp = ssrbf_psi_comp.PSICOMP_SSRBF()
 
     def K_of_r(self, r):
         return self.variance * np.exp(-0.5 * r**2)
@@ -44,289 +38,39 @@ class RBF(Stationary):
     #---------------------------------------#
 
     def psi0(self, Z, variational_posterior):
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)[0]
         else:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[0]
-        else:
-#             return self.Kdiag(variational_posterior.mean)
-            return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[0]
 
     def psi1(self, Z, variational_posterior):
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)[1]
         else:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[1]
-        else:
-            return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[1]
 
     def psi2(self, Z, variational_posterior):
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior.mean, variational_posterior.variance, variational_posterior.binary_prob)[2]
         else:
             return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[2]
-        else:
-            return self.psicomp.psicomputations(self.variance, self.lengthscale, Z, variational_posterior)[2]
 
     def update_gradients_expectations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, Z, variational_posterior):
-        # Spike-and-Slab GPLVM
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             self.psicomp.update_gradients_expectations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
         else:
-                dL_dvar, dL_dlengscale, _, _, _, _ = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
+            dL_dvar, dL_dlengscale = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)[:2]
             self.variance.gradient = dL_dvar
             self.lengthscale.gradient = dL_dlengscale
 
-        elif isinstance(variational_posterior, variational.NormalPosterior):
-            dL_dvar, dL_dlengscale, _, _, _ = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
-            self.variance.gradient = dL_dvar
-            self.lengthscale.gradient = dL_dlengscale
-
-#             l2 = self.lengthscale**2
-#             if l2.size != self.input_dim:
-#                 l2 = l2*np.ones(self.input_dim) 
-#             #contributions from psi0:
-#             self.variance.gradient = np.sum(dL_dpsi0)
-#             self.lengthscale.gradient = 0.
-#  
-# #             #from psi1
-#             denom, _, dist_sq, psi1 = self._psi1computations(Z, variational_posterior)
-#             d_length = psi1[:,:,None] * ((dist_sq - 1.)/(self.lengthscale*denom) +1./self.lengthscale)
-#             dpsi1_dlength = d_length * dL_dpsi1[:, :, None]
-#             print dpsi1_dlength.sum(0).sum(0)
-#             if self.ARD:
-#                 self.lengthscale.gradient += dpsi1_dlength.sum(0).sum(0)
-#             else:
-#                 self.lengthscale.gradient += dpsi1_dlength.sum()
-#             self.variance.gradient += np.sum(dL_dpsi1 * psi1) / self.variance
-#             #from psi2
-#             S = variational_posterior.variance
-#             _, Zdist_sq, _, mudist_sq, psi2 = self._psi2computations(Z, variational_posterior)
-#             if not self.ARD:
-#                 self.lengthscale.gradient += self._weave_psi2_lengthscale_grads(dL_dpsi2, psi2, Zdist_sq, S, mudist_sq, l2).sum()
-#             else:
-#                 self.lengthscale.gradient += self._weave_psi2_lengthscale_grads(dL_dpsi2, psi2, Zdist_sq, S, mudist_sq, l2)
-# #            print self._weave_psi2_lengthscale_grads(dL_dpsi2, psi2, Zdist_sq, S, mudist_sq, l2)
-#  
-#             self.variance.gradient += 2.*np.sum(dL_dpsi2 * psi2)/self.variance
-
-        else:
-            raise ValueError, "unknown distriubtion received for psi-statistics"
-
     def gradients_Z_expectations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, Z, variational_posterior):
-        # Spike-and-Slab GPLVM
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             return self.psicomp.gradients_Z_expectations(dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
         else:
-                _, _, dL_dZ, _, _, _ = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
+            return self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)[2]
-                return dL_dZ
-                
-        elif isinstance(variational_posterior, variational.NormalPosterior):
-            _, _, dL_dZ, _, _ = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
-            return dL_dZ
-#             
-#             l2 = self.lengthscale **2
-# 
-#             #psi1
-#             denom, dist, dist_sq, psi1 = self._psi1computations(Z, variational_posterior)
-#             grad = np.einsum('ij,ij,ijk,ijk->jk', dL_dpsi1, psi1, dist, -1./(denom*l2))
-# 
-#             #psi2
-#             Zdist, Zdist_sq, mudist, mudist_sq, psi2 = self._psi2computations(Z, variational_posterior)
-#             term1 = Zdist / l2 # M, M, Q
-#             S = variational_posterior.variance
-#             term2 = mudist / (2.*S[:,None,None,:] + l2) # N, M, M, Q
-# 
-#             grad += 2.*np.einsum('ijk,ijk,ijkl->kl', dL_dpsi2, psi2, term1[None,:,:,:] + term2)
-# 
-#             return grad
-        else:
-            raise ValueError, "unknown distriubtion received for psi-statistics"
 
     def gradients_qX_expectations(self, dL_dpsi0, dL_dpsi1, dL_dpsi2, Z, variational_posterior):
-        # Spike-and-Slab GPLVM
-        if isinstance(variational_posterior, variational.SpikeAndSlabPosterior):
         if self.useGPU:
             return self.psicomp.gradients_qX_expectations(dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
         else:
-                _, _, _, dL_dmu, dL_dS, dL_dgamma = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
+            return self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)[3:]
-                return dL_dmu, dL_dS, dL_dgamma
-            
-        elif isinstance(variational_posterior, variational.NormalPosterior):
-            _, _, _, dL_dmu, dL_dS = self.psicomp.psiDerivativecomputations(dL_dpsi0, dL_dpsi1, dL_dpsi2, self.variance, self.lengthscale, Z, variational_posterior)
- 
-#             l2 = self.lengthscale **2
-#             #psi1
-#             denom, dist, dist_sq, psi1 = self._psi1computations(Z, variational_posterior)
-#             tmp = psi1[:, :, None] / l2 / denom
-#             grad_mu = np.sum(dL_dpsi1[:, :, None] * tmp * dist, 1)
-#             grad_S = np.sum(dL_dpsi1[:, :, None] * 0.5 * tmp * (dist_sq - 1), 1)
-#             #psi2
-#             _, _, mudist, mudist_sq, psi2 = self._psi2computations(Z, variational_posterior)
-#             S = variational_posterior.variance
-#             tmp = psi2[:, :, :, None] / (2.*S[:,None,None,:] + l2)
-#             grad_mu += -2.*np.einsum('jk,ijkl,ijkl->il', dL_dpsi2, tmp , mudist)
-#             grad_S += np.einsum('jk,ijkl,ijkl->il', dL_dpsi2 , tmp , (2.*mudist_sq - 1))
-              
-            return dL_dmu, dL_dS
-
-        else:
-            raise ValueError, "unknown distriubtion received for psi-statistics"
-
-        #return grad_mu, grad_S
-
-    #---------------------------------------#
-    #            Precomputations            #
-    #---------------------------------------#
-
-    @Cache_this(limit=1)
-    def _psi1computations(self, Z, vp):
-        mu, S = vp.mean, vp.variance
-        l2 = self.lengthscale **2
-        denom = S[:, None, :] / l2 + 1. # N,1,Q
-        dist = Z[None, :, :] - mu[:, None, :] # N,M,Q
-        dist_sq = np.square(dist) / l2 / denom # N,M,Q
-        exponent = -0.5 * np.sum(dist_sq + np.log(denom), -1)#N,M
-        psi1 = self.variance * np.exp(exponent) # N,M
-        return denom, dist, dist_sq, psi1
-
-
-    @Cache_this(limit=1, ignore_args=(0,))
-    def _Z_distances(self, Z):
-        Zhat = 0.5 * (Z[:, None, :] + Z[None, :, :]) # M,M,Q
-        Zdist = 0.5 * (Z[:, None, :] - Z[None, :, :]) # M,M,Q
-        return Zhat, Zdist
-
-    @Cache_this(limit=1)
-    def _psi2computations(self, Z, vp):
-
-        if config.getboolean('parallel', 'openmp'):
-            pragma_string = '#pragma omp parallel for private(tmp, exponent_tmp)'
-            header_string = '#include <omp.h>'
-            libraries = ['gomp']
-        else:
-            pragma_string = ''
-            header_string = ''
-            libraries = []
-
-        mu, S = vp.mean, vp.variance
-
-        N, Q = mu.shape
-        M = Z.shape[0]
-
-        #compute required distances
-        Zhat, Zdist = self._Z_distances(Z)
-        Zdist_sq = np.square(Zdist / self.lengthscale) # M,M,Q
-
-        #allocate memory for the things we want to compute
-        mudist = np.empty((N, M, M, Q))
-        mudist_sq = np.empty((N, M, M, Q))
-        psi2 = np.empty((N, M, M))
-
-        l2 = self.lengthscale **2
-        denom = (2.*S[:,None,None,:] / l2) + 1. # N,Q
-        half_log_denom = 0.5 * np.log(denom[:,0,0,:])
-        denom_l2 = denom[:,0,0,:]*l2
-
-        variance_sq = float(np.square(self.variance))
-        code = """
-        double tmp, exponent_tmp;
-        %s 
-        for (int n=0; n<N; n++)
-        {
-            for (int m=0; m<M; m++)
-            {
-                for (int mm=0; mm<(m+1); mm++)
-                {
-                    exponent_tmp = 0.0;
-                    for (int q=0; q<Q; q++)
-                    {
-                        //compute mudist
-                        tmp = mu(n,q) - Zhat(m,mm,q);
-                        mudist(n,m,mm,q) = tmp;
-                        mudist(n,mm,m,q) = tmp;
-
-                        //now mudist_sq
-                        tmp = tmp*tmp/denom_l2(n,q);
-                        mudist_sq(n,m,mm,q) = tmp;
-                        mudist_sq(n,mm,m,q) = tmp;
-
-                        //now exponent
-                        tmp = -Zdist_sq(m,mm,q) - tmp - half_log_denom(n,q);
-                        exponent_tmp += tmp;
-                    }
-                    //compute psi2 by exponentiating
-                    psi2(n,m,mm) = variance_sq * exp(exponent_tmp);
-                    psi2(n,mm,m) = psi2(n,m,mm);
-                }
-            }
-        }
-        """ % pragma_string
-
-        support_code = """
-        %s
-        #include <math.h>
-        """ % header_string
-        mu = param_to_array(mu)
-        weave.inline(code, support_code=support_code, libraries=libraries,
-                     arg_names=['N', 'M', 'Q', 'mu', 'Zhat', 'mudist_sq', 'mudist', 'denom_l2', 'Zdist_sq', 'half_log_denom', 'psi2', 'variance_sq'],
-                     type_converters=weave.converters.blitz, **self.weave_options)
-
-        return Zdist, Zdist_sq, mudist, mudist_sq, psi2
-
-    def _weave_psi2_lengthscale_grads(self, dL_dpsi2, psi2, Zdist_sq, S, mudist_sq, l2):
-
-        #here's the einsum equivalent, it's ~3 times slower
-        #return 2.*np.einsum( 'ijk,ijk,ijkl,il->l', dL_dpsi2, psi2, Zdist_sq * (2.*S[:,None,None,:]/l2 + 1.) + mudist_sq + S[:, None, None, :] / l2, 1./(2.*S + l2))*self.lengthscale
-
-        result = np.zeros(self.input_dim)
-        if config.getboolean('parallel', 'openmp'):
-            pragma_string = '#pragma omp parallel for reduction(+:tmp)'
-            header_string = '#include <omp.h>'
-            libraries = ['gomp']
-        else:
-            pragma_string = ''
-            header_string = ''
-            libraries = []
-        code = """
-        double tmp;
-        for(int q=0; q<Q; q++)
-        {
-            tmp = 0.0;
-            %s
-            for(int n=0; n<N; n++)
-            {
-                for(int m=0; m<M; m++)
-                {
-                    //diag terms
-                    tmp += dL_dpsi2(n,m,m) * psi2(n,m,m) * (Zdist_sq(m,m,q) * (2.0*S(n,q)/l2(q) + 1.0) + mudist_sq(n,m,m,q) + S(n,q)/l2(q)) / (2.0*S(n,q) + l2(q)) ;
-
-                    //off-diag terms
-                    for(int mm=0; mm<m; mm++)
-                    {
-                        tmp += 2.0 * dL_dpsi2(n,m,mm) * psi2(n,m,mm) * (Zdist_sq(m,mm,q) * (2.0*S(n,q)/l2(q) + 1.0) + mudist_sq(n,m,mm,q) + S(n,q)/l2(q)) / (2.0*S(n,q) + l2(q)) ;
-                    }
-                }
-            }
-            result(q) = tmp;
-        }
-
-        """ % pragma_string
-        support_code = """
-        %s
-        #include <math.h>
-        """ % header_string
-        N,Q = S.shape
-        M = psi2.shape[-1]
-
-        S = param_to_array(S)
-        weave.inline(code, support_code=support_code, libraries=libraries,
-                     arg_names=['psi2', 'dL_dpsi2', 'N', 'M', 'Q', 'mudist_sq', 'l2', 'Zdist_sq', 'S', 'result'],
-                     type_converters=weave.converters.blitz, **self.weave_options)
-
-        return 2.*result*self.lengthscale

GPy/models/ss_gplvm.py

@@ -64,7 +64,6 @@ class SSGPLVM(SparseGP):
 
         if kernel is None:
             kernel = kern.RBF(input_dim, lengthscale=fracs, ARD=True) # + kern.white(input_dim)
-        kernel.set_for_SpikeAndSlab()
         
         if inference_method is None:
             inference_method = VarDTC_minibatch(mpi_comm=mpi_comm)