maint: Remove tabs (and some trailing spaces)

GPy/core/parameterization/priors.py

@@ -910,12 +910,12 @@ class DGPLVM_Lamda(Prior, Parameterized):
     def lnpdf(self, x):
         x = x.reshape(self.x_shape)
 
-	#!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!
-	#self.lamda.values[:] = self.lamda.values/self.lamda.values.sum()	
+        #self.lamda.values[:] = self.lamda.values/self.lamda.values.sum()
 
         xprime = x.dot(np.diagflat(self.lamda))
         x = xprime
-	# print x
+        # print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
         M_i = self.compute_Mi(cls)
@@ -932,7 +932,7 @@ class DGPLVM_Lamda(Prior, Parameterized):
         x = x.reshape(self.x_shape)
         xprime = x.dot(np.diagflat(self.lamda))
         x = xprime
-	# print x
+        # print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
         M_i = self.compute_Mi(cls)
@@ -967,11 +967,11 @@ class DGPLVM_Lamda(Prior, Parameterized):
 
         DPxprim_Dlamda = DPx_Dx.dot(x)
 
-    	# Because of the GPy we need to transpose our matrix so that it gets the same shape as out matrix (denominator layout!!!)
+        # Because of the GPy we need to transpose our matrix so that it gets the same shape as out matrix (denominator layout!!!)
         DPxprim_Dlamda = DPxprim_Dlamda.T
 
         self.lamda.gradient = np.diag(DPxprim_Dlamda)
-	# print DPxprim_Dx
+        # print DPxprim_Dx
         return DPxprim_Dx
 
 
@@ -1046,7 +1046,7 @@ class DGPLVM_T(Prior):
         M_i = np.zeros((self.classnum, self.dim))
         for i in cls:
             # Mean of each class
-	    # class_i = np.multiply(cls[i],vec)
+            # class_i = np.multiply(cls[i],vec)
             class_i = cls[i]
             M_i[i] = np.mean(class_i, axis=0)
         return M_i
@@ -1155,7 +1155,7 @@ class DGPLVM_T(Prior):
         x = x.reshape(self.x_shape)
         xprim = x.dot(self.vec)
         x = xprim
-	# print x  
+        # print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
         M_i = self.compute_Mi(cls)
@@ -1163,7 +1163,7 @@ class DGPLVM_T(Prior):
         Sw = self.compute_Sw(cls, M_i)
         # Sb_inv_N = np.linalg.inv(Sb + np.eye(Sb.shape[0]) * (np.diag(Sb).min() * 0.1))
         #Sb_inv_N = np.linalg.inv(Sb+np.eye(Sb.shape[0])*0.1)
-	#print 'SB_inv: ', Sb_inv_N
+        #print 'SB_inv: ', Sb_inv_N
         #Sb_inv_N = pdinv(Sb+ np.eye(Sb.shape[0]) * (np.diag(Sb).min() * 0.1))[0]
         Sb_inv_N = pdinv(Sb+np.eye(Sb.shape[0])*0.1)[0]
         return (-1 / self.sigma2) * np.trace(Sb_inv_N.dot(Sw))
@@ -1173,7 +1173,7 @@ class DGPLVM_T(Prior):
         x = x.reshape(self.x_shape)
         xprim = x.dot(self.vec)
         x = xprim
-	# print x       
+        # print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
         M_i = self.compute_Mi(cls)
@@ -1188,7 +1188,7 @@ class DGPLVM_T(Prior):
         # Calculating inverse of Sb and its transpose and minus
         # Sb_inv_N = np.linalg.inv(Sb + np.eye(Sb.shape[0]) * (np.diag(Sb).min() * 0.1))
         #Sb_inv_N = np.linalg.inv(Sb+np.eye(Sb.shape[0])*0.1)
-	#print 'SB_inv: ',Sb_inv_N
+        #print 'SB_inv: ',Sb_inv_N
         #Sb_inv_N = pdinv(Sb+ np.eye(Sb.shape[0]) * (np.diag(Sb).min() * 0.1))[0]
         Sb_inv_N = pdinv(Sb+np.eye(Sb.shape[0])*0.1)[0]
         Sb_inv_N_trans = np.transpose(Sb_inv_N)
@@ -1376,3 +1376,4 @@ class StudentT(Prior):
         from scipy.stats import t
         ret = t.rvs(self.nu, loc=self.mu, scale=self.sigma, size=n)
         return ret
+

GPy/kern/src/ODE_t.py

@@ -146,7 +146,7 @@ class ODE_t(Kern):
                                 elif i==1 and j==1:
                                     dkYdvart[ss1,ss2] = (k1(tdist[ss1,ss2]) + 1. )* kyy(tdist[ss1,ss2])
                                     dkYdlent[ss1,ss2] = vyt*dkyydlyt(tdist[ss1,ss2])*( k1(tdist[ss1,ss2]) + 1. ) +\
-                          			vyt*kyy(tdist[ss1,ss2])*dk1dlyt(tdist[ss1,ss2])
+                                                        vyt*kyy(tdist[ss1,ss2])*dk1dlyt(tdist[ss1,ss2])
                                     dkdubias[ss1,ss2] = 1
                                 else:
                                     dkYdvart[ss1,ss2] = (-k4(ttdist[ss1,ss2])+1)*kyy(tdist[ss1,ss2])
@@ -157,9 +157,9 @@ class ODE_t(Kern):
                                     #dkYdlent[ss1,ss2] = vyt*dkyydlyt(tdist[ss1,ss2])* (-2*lyt*(ttdist[ss1,ss2])+1.)+\
                                     #vyt*kyy(tdist[ss1,ss2])*(-2)*(ttdist[ss1,ss2])
 
-
                 self.variance_Yt.gradient = np.sum(dkYdvart * dL_dK)
 
                 self.lengthscale_Yt.gradient =  np.sum(dkYdlent*(-0.5*self.lengthscale_Yt**(-2)) * dL_dK)
 
                 self.ubias.gradient = np.sum(dkdubias * dL_dK)
+

GPy/kern/src/grid_kerns.py

@@ -10,67 +10,67 @@ from paramz.caching import Cache_this
 
 class GridKern(Stationary):
 
-	def __init__(self, input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=False):
+    def __init__(self, input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=False):
-		super(GridKern, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, useGPU=useGPU)
+        super(GridKern, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, useGPU=useGPU)
-		self.originalDimensions = originalDimensions
+        self.originalDimensions = originalDimensions
 
-	@Cache_this(limit=3, ignore_args=())
+    @Cache_this(limit=3, ignore_args=())
-	def dKd_dVar(self, X, X2=None):
+    def dKd_dVar(self, X, X2=None):
-		"""
+        """
-		Derivative of Kernel function wrt variance applied on inputs X and X2.
+        Derivative of Kernel function wrt variance applied on inputs X and X2.
-		In the stationary case there is an inner function depending on the
+        In the stationary case there is an inner function depending on the
-		distances from X to X2, called r.
+        distances from X to X2, called r.
 
-		dKd_dVar(X, X2) = dKdVar_of_r((X-X2)**2)
+        dKd_dVar(X, X2) = dKdVar_of_r((X-X2)**2)
-		"""
+        """
-		r = self._scaled_dist(X, X2)
+        r = self._scaled_dist(X, X2)
-		return self.dKdVar_of_r(r)
+        return self.dKdVar_of_r(r)
 
-	@Cache_this(limit=3, ignore_args=())
+    @Cache_this(limit=3, ignore_args=())
-	def dKd_dLen(self, X, dimension, lengthscale, X2=None):
+    def dKd_dLen(self, X, dimension, lengthscale, X2=None):
-		"""
+        """
-		Derivate of Kernel function wrt lengthscale applied on inputs X and X2.
+        Derivate of Kernel function wrt lengthscale applied on inputs X and X2.
-		In the stationary case there is an inner function depending on the
+        In the stationary case there is an inner function depending on the
-		distances from X to X2, called r.
+        distances from X to X2, called r.
 
-		dKd_dLen(X, X2) = dKdLen_of_r((X-X2)**2)
+        dKd_dLen(X, X2) = dKdLen_of_r((X-X2)**2)
-		"""
+        """
-		r = self._scaled_dist(X, X2)
+        r = self._scaled_dist(X, X2)
-		return self.dKdLen_of_r(r, dimension, lengthscale)
+        return self.dKdLen_of_r(r, dimension, lengthscale)
 
 class GridRBF(GridKern):
-	"""
+    """
-	Similar to regular RBF but supplemented with methods required for Gaussian grid regression
+    Similar to regular RBF but supplemented with methods required for Gaussian grid regression
-	Radial Basis Function kernel, aka squared-exponential, exponentiated quadratic or Gaussian kernel:
+    Radial Basis Function kernel, aka squared-exponential, exponentiated quadratic or Gaussian kernel:
 
-	.. math::
+    .. math::
 
-	   k(r) = \sigma^2 \exp \\bigg(- \\frac{1}{2} r^2 \\bigg)
+       k(r) = \sigma^2 \exp \\bigg(- \\frac{1}{2} r^2 \\bigg)
 
-	"""
+    """
-	_support_GPU = True
+    _support_GPU = True
-	def __init__(self, input_dim, variance=1., lengthscale=None, ARD=False, active_dims=None, name='gridRBF', originalDimensions=1, useGPU=False):
+    def __init__(self, input_dim, variance=1., lengthscale=None, ARD=False, active_dims=None, name='gridRBF', originalDimensions=1, useGPU=False):
-		super(GridRBF, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=useGPU)
+        super(GridRBF, self).__init__(input_dim, variance, lengthscale, ARD, active_dims, name, originalDimensions, useGPU=useGPU)
 
-	def K_of_r(self, r):
+    def K_of_r(self, r):
-		return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 *  r**2)
+        return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 *  r**2)
 
-	def dKdVar_of_r(self, r):
+    def dKdVar_of_r(self, r):
-		"""
+        """
-		Compute derivative of kernel wrt variance
+        Compute derivative of kernel wrt variance
-		"""
+        """
-		return np.exp(-0.5 * r**2)
+        return np.exp(-0.5 * r**2)
 
-	def dKdLen_of_r(self, r, dimCheck, lengthscale):
+    def dKdLen_of_r(self, r, dimCheck, lengthscale):
-		"""
+        """
-		Compute derivative of kernel for dimension wrt lengthscale
+        Compute derivative of kernel for dimension wrt lengthscale
-		Computation of derivative changes when lengthscale corresponds to
+        Computation of derivative changes when lengthscale corresponds to
-		the dimension of the kernel whose derivate is being computed. 
+        the dimension of the kernel whose derivate is being computed.
-		"""
+        """
-		if (dimCheck == True):
+        if (dimCheck == True):
-			return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) * (r**2) / (lengthscale**(float(1)/self.originalDimensions))
+            return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) * (r**2) / (lengthscale**(float(1)/self.originalDimensions))
-		else:
+        else:
-			return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) / (lengthscale**(float(1)/self.originalDimensions))
+            return (self.variance**(float(1)/self.originalDimensions)) * np.exp(-0.5 * r**2) / (lengthscale**(float(1)/self.originalDimensions))
 
-	def dK_dr(self, r):
+    def dK_dr(self, r):
-		return -r*self.K_of_r(r)
+        return -r*self.K_of_r(r)