Merge branch 'devel' of https://github.com/SheffieldML/GPy into devel

GPy/core/parameterization/index_operations.py

@@ -5,7 +5,7 @@ import numpy
 from numpy.lib.function_base import vectorize
 from .lists_and_dicts import IntArrayDict
 from functools import reduce
-from transformations import Transformation
+from .transformations import Transformation
 
 def extract_properties_to_index(index, props):
     prop_index = dict()

GPy/core/parameterization/parameter_core.py

@@ -440,7 +440,7 @@ class Indexable(Nameable, Updateable):
         log_j = 0.
         priored_indexes = np.hstack([i for p, i in self.priors.items()])
         for c,j in self.constraints.items():
-            if c is 'fixed':continue
+            if not isinstance(c, Transformation):continue
             for jj in j:
                 if jj in priored_indexes:
                     log_j += c.log_jacobian(x[jj])
@@ -457,6 +457,7 @@ class Indexable(Nameable, Updateable):
         #add in jacobian derivatives if transformed
         priored_indexes = np.hstack([i for p, i in self.priors.items()])
         for c,j in self.constraints.items():
+            if not isinstance(c, Transformation):continue
             for jj in j:
                 if jj in priored_indexes:
                     ret[jj] += c.log_jacobian_grad(x[jj])

GPy/core/parameterization/parameterized.py

@@ -6,10 +6,10 @@ import numpy; np = numpy
 import itertools
 from re import compile, _pattern_type
 from .param import ParamConcatenation
-from parameter_core import HierarchyError, Parameterizable, adjust_name_for_printing
+from .parameter_core import HierarchyError, Parameterizable, adjust_name_for_printing
 
 import logging
-from index_operations import ParameterIndexOperationsView
+from .index_operations import ParameterIndexOperationsView
 logger = logging.getLogger("parameters changed meta")
 
 class ParametersChangedMeta(type):

GPy/core/parameterization/priors.py

@@ -758,12 +758,12 @@ class DGPLVM_Lamda(Prior, Parameterized):
         self.sigma2 = sigma2
         # self.x = x
         self.lbl = lbl
-	self.lamda = lamda
+        self.lamda = lamda
         self.classnum = lbl.shape[1]
         self.datanum = lbl.shape[0]
         self.x_shape = x_shape
         self.dim = x_shape[1]
-	self.lamda = Param('lamda', np.diag(lamda))
+        self.lamda = Param('lamda', np.diag(lamda))
         self.link_parameter(self.lamda)
 
     def get_class_label(self, y):
@@ -789,7 +789,7 @@ class DGPLVM_Lamda(Prior, Parameterized):
         M_i = np.zeros((self.classnum, self.dim))
         for i in cls:
             # Mean of each class
-	    class_i = cls[i]
+            class_i = cls[i]
             M_i[i] = np.mean(class_i, axis=0)
         return M_i
 
@@ -899,8 +899,8 @@ class DGPLVM_Lamda(Prior, Parameterized):
 	#!!!!!!!!!!!!!!!!!!!!!!!!!!!
 	#self.lamda.values[:] = self.lamda.values/self.lamda.values.sum()	
 
-	xprime = x.dot(np.diagflat(self.lamda))
-	x = xprime
+        xprime = x.dot(np.diagflat(self.lamda))
+        x = xprime
 	# print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
@@ -910,14 +910,14 @@ class DGPLVM_Lamda(Prior, Parameterized):
         # 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)
         #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 = pdinv(Sb + np.eye(Sb.shape[0])*0.1)[0]
         return (-1 / self.sigma2) * np.trace(Sb_inv_N.dot(Sw))
 
     # This function calculates derivative of the log of prior function
     def lnpdf_grad(self, x):
         x = x.reshape(self.x_shape)
-	xprime = x.dot(np.diagflat(self.lamda))
-	x = xprime
+        xprime = x.dot(np.diagflat(self.lamda))
+        x = xprime
 	# print x
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
@@ -934,7 +934,7 @@ class DGPLVM_Lamda(Prior, Parameterized):
         # 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)
         #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 = pdinv(Sb + np.eye(Sb.shape[0])*0.1)[0]
         Sb_inv_N_trans = np.transpose(Sb_inv_N)
         Sb_inv_N_trans_minus = -1 * Sb_inv_N_trans
         Sw_trans = np.transpose(Sw)
@@ -951,14 +951,14 @@ class DGPLVM_Lamda(Prior, Parameterized):
         # Because of the GPy we need to transpose our matrix so that it gets the same shape as out matrix (denominator layout!!!)
         DPxprim_Dx = DPxprim_Dx.T
     
-    	DPxprim_Dlamda = DPx_Dx.dot(x)
+        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!!!)
-    	DPxprim_Dlamda = DPxprim_Dlamda.T
+        DPxprim_Dlamda = DPxprim_Dlamda.T
 
-	self.lamda.gradient = np.diag(DPxprim_Dlamda)
+        self.lamda.gradient = np.diag(DPxprim_Dlamda)
 	# print DPxprim_Dx
-    	return DPxprim_Dx
+        return DPxprim_Dx
 
 
     # def frb(self, x):
@@ -1139,8 +1139,8 @@ class DGPLVM_T(Prior):
     # This function calculates log of our prior
     def lnpdf(self, x):
         x = x.reshape(self.x_shape)
-	xprim = x.dot(self.vec)
-	x = xprim
+        xprim = x.dot(self.vec)
+        x = xprim
 	# print x  
         cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
@@ -1156,11 +1156,11 @@ class DGPLVM_T(Prior):
 
     # This function calculates derivative of the log of prior function
     def lnpdf_grad(self, x):
-	x = x.reshape(self.x_shape)
-	xprim = x.dot(self.vec)
-	x = xprim 
+        x = x.reshape(self.x_shape)
+        xprim = x.dot(self.vec)
+        x = xprim 
 	# print x       
-	cls = self.compute_cls(x)
+        cls = self.compute_cls(x)
         M_0 = np.mean(x, axis=0)
         M_i = self.compute_Mi(cls)
         Sb = self.compute_Sb(cls, M_i, M_0)

GPy/core/parameterization/transformations.py

@@ -35,12 +35,12 @@ class Transformation(object):
         """
         compute the log of the jacobian of f, evaluated at f(x)= model_param
         """
-	raise NotImplementedError
+        raise NotImplementedError
     def log_jacobian_grad(self, model_param):
         """
         compute the drivative of the log of the jacobian of f, evaluated at f(x)= model_param
         """
-	raise NotImplementedError
+        raise NotImplementedError
     def gradfactor(self, model_param, dL_dmodel_param):
         """ df(opt_param)_dopt_param evaluated at self.f(opt_param)=model_param, times the gradient dL_dmodel_param,