Merge branch 'master' of github.com:SheffieldML/GPy into debug

GPy/core/model.py

@@ -308,9 +308,7 @@ class model(parameterised):
         numerical_gradient = (f1-f2)/(2*dx)
         ratio = (f1-f2)/(2*np.dot(dx,gradient))
         if verbose:
-            #print "gradient = ",gradient
+            print "Gradient ratio = ", ratio, '\n'
-            #print "numerical gradient = ",numerical_gradient
-            print " Gradient ratio = ", ratio, '\n'
             sys.stdout.flush()
 
         if (np.abs(1.-ratio)<tolerance) and not np.isnan(ratio):
@@ -319,10 +317,24 @@ class model(parameterised):
         else:
             if verbose:
                 print "Global check failed. Testing individual gradients\n"
-            try:
+
-                names = self.extract_param_names()
+                try:
-            except NotImplementedError:
+                    names = self.extract_param_names()
-                names = ['Variable %i'%i for i in range(len(x))]
+                except NotImplementedError:
+                    names = ['Variable %i'%i for i in range(len(x))]
+
+                # Prepare for pretty-printing
+                header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']
+                max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])
+                float_len = 10
+                cols = [max_names]
+                cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])
+                cols = np.array(cols) + 5
+                header_string = ["{h:^{col}}".format(h = header[i], col = cols[i]) for i in range(len(cols))]
+                header_string = map(lambda x: '|'.join(x), [header_string])
+                separator = '-'*len(header_string[0])
+                print '\n'.join([header_string[0], separator])
+
             for i in range(len(x)):
                 xx = x.copy()
                 xx[i] += step
@@ -338,11 +350,20 @@ class model(parameterised):
                 numerical_gradient = (f1-f2)/(2*step)
                 ratio = (f1-f2)/(2*step*gradient)
                 difference = np.abs((f1-f2)/2/step - gradient)
+
                 if verbose:
-                    print "{0:10s}   ratio: {1:15f}   difference: {2:15f}   analytical: {3:15f}    numerical: {4:15f}".format(names[i], float(ratio), float(difference), gradient, float(numerical_gradient)),
                     if (np.abs(ratio-1)<tolerance):
-                        print " "+'\033[92m' + u"\u2713" + '\033[0m' # green chackmark
+                        formatted_name = "\033[92m {0} \033[0m".format(names[i])
                     else:
-                        print " "+'\033[91m' + u"\u2717" + '\033[0m' # red crossmark
+                        formatted_name = "\033[91m {0} \033[0m".format(names[i])
+                    r = '%.6f' % float(ratio)
+                    d = '%.6f' % float(difference)
+                    g = '%.6f' % gradient
+                    ng = '%.6f' % float(numerical_gradient)
+                    grad_string = "{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])
+                    print grad_string
+
+            print ''
+            
             return False
         return True

GPy/inference/optimization.py

@@ -3,7 +3,13 @@
 
 
 from scipy import optimize
-# import rasmussens_minimize as rasm
+
+try:
+    import rasmussens_minimize as rasm
+    rasm_available = True
+except ImportError:
+    rasm_available = False
+
 import pdb
 import pylab as pb
 import datetime as dt
@@ -159,43 +165,45 @@ class opt_simplex(Optimizer):
         self.trace = None
 
 
-# class opt_rasm(Optimizer):
+class opt_rasm(Optimizer):
-#     def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
-#         Optimizer.__init__(self, *args, **kwargs)
+        Optimizer.__init__(self, *args, **kwargs)
-#         self.opt_name = "Rasmussen's Conjugate Gradient"
+        self.opt_name = "Rasmussen's Conjugate Gradient"
 
-#     def opt(self):
+    def opt(self, f_fp = None, f = None, fp = None):
-#         """
+        """
-#         Run Rasmussen's Conjugate Gradient optimizer
+        Run Rasmussen's Conjugate Gradient optimizer
-#         """
+        """
 
-#         assert self.f_fp != None, "Rasmussen's minimizer requires f_fp"
+        assert f_fp != None, "Rasmussen's minimizer requires f_fp"
-#         statuses = ['Converged', 'Line search failed', 'Maximum number of f evaluations reached',
+        statuses = ['Converged', 'Line search failed', 'Maximum number of f evaluations reached',
-#                 'NaNs in optimization']
+                'NaNs in optimization']
 
-#         opt_dict = {}
+        opt_dict = {}
-#         if self.xtol is not None:
+        if self.xtol is not None:
-#             print "WARNING: minimize doesn't have an xtol arg, so I'm going to ignore it"
+            print "WARNING: minimize doesn't have an xtol arg, so I'm going to ignore it"
-#         if self.ftol is not None:
+        if self.ftol is not None:
-#             print "WARNING: minimize doesn't have an ftol arg, so I'm going to ignore it"
+            print "WARNING: minimize doesn't have an ftol arg, so I'm going to ignore it"
-#         if self.gtol is not None:
+        if self.gtol is not None:
-#             print "WARNING: minimize doesn't have an gtol arg, so I'm going to ignore it"
+            print "WARNING: minimize doesn't have an gtol arg, so I'm going to ignore it"
 
-#         opt_result = rasm.minimize(self.x_init, self.f_fp, (), messages = self.messages,
+        opt_result = rasm.minimize(self.x_init, f_fp, (), messages = self.messages,
-#                 maxnumfuneval = self.max_f_eval)
+                                   maxnumfuneval = self.max_f_eval)
-#         self.x_opt = opt_result[0]
+        self.x_opt = opt_result[0]
-#         self.f_opt = opt_result[1][-1]
+        self.f_opt = opt_result[1][-1]
-#         self.funct_eval = opt_result[2]
+        self.funct_eval = opt_result[2]
-#         self.status = statuses[opt_result[3]]
+        self.status = statuses[opt_result[3]]
 
-#         self.trace = opt_result[1]
+        self.trace = opt_result[1]
 
 def get_optimizer(f_min):
     optimizers = {'fmin_tnc': opt_tnc,
-          # 'rasmussen': opt_rasm,
           'simplex': opt_simplex,
           'lbfgsb': opt_lbfgsb}
 
+    if rasm_available:
+        optimizers['rasmussen'] = opt_rasm
+
     for opt_name in optimizers.keys():
         if opt_name.lower().find(f_min.lower()) != -1:
             return optimizers[opt_name]

GPy/models/warped_GP.py

@@ -22,7 +22,7 @@ class warpedGP(GP_regression):
         if warping_function == None:
             self.warping_function = TanhWarpingFunction(warping_terms)
             # self.warping_params = np.random.randn(self.warping_function.n_terms, 3)
-            self.warping_params = np.ones((self.warping_function.n_terms, 3))*1.0 # TODO better init
+            self.warping_params = np.ones((self.warping_function.n_terms, 3))*0.0 # TODO better init
             self.warp_params_shape = (self.warping_function.n_terms, 3) # todo get this from the subclass
 
         self.Z = Y.copy()

GPy/util/datasets.py

@@ -1,5 +1,4 @@
 import os
-import posix
 import pylab as pb
 import numpy as np
 import GPy