Verbosity flags for optimisation and compilation now used (GPflow#202)

* Verbosity flags for optimisation and compilation now used.

* Jitter level now read from config.

* Exclude testing print statements

* Added missed jitter levels.

* bugfix in gpmc.py

.coveragerc

@@ -10,3 +10,4 @@ exclude_lines =
     raise AssertionError
     raise NotImplementedError
     if __name__ == .__main__.:
+    print

GPflow/_settings.py

@@ -41,7 +41,6 @@ def namedtuplify(mapping):  # thank you https://gist.github.com/hangtwenty/59604
 
 
 def read_config_file(path=None):
-
     c = configparser.ConfigParser()
 
     if path is None:  # pragma: no cover
@@ -58,8 +57,9 @@ def read_config_file(path=None):
             if c.read(os.path.join(loc, '.gpflowrc')):
                 break
     else:
-        assert(c.read(path))
+        assert (c.read(path))
     return c
 
+
 c = read_config_file()
 settings = namedtuplify(c._sections)

GPflow/conditionals.py

@@ -16,6 +16,7 @@
 from .tf_hacks import eye
 import tensorflow as tf
 from .scoping import NameScoped
+from ._settings import settings
 
 
 @NameScoped("conditional")
@@ -61,7 +62,7 @@ def conditional(Xnew, X, kern, f, full_cov=False, q_sqrt=None, whiten=False):
     # compute kernel stuff
     num_data = tf.shape(X)[0]
     Kmn = kern.K(X, Xnew)
-    Kmm = kern.K(X) + eye(num_data) * 1e-6
+    Kmm = kern.K(X) + eye(num_data) * settings.numerics.jitter_level
     Lm = tf.cholesky(Kmm)
 
     # Compute the projection matrix A

GPflow/gpflowrc

@@ -1,6 +1,7 @@
 [verbosity]
 tf_compile_verb = False
 hmc_verb = True
+optimisation_verb = False
 
 [dtypes]
 float_type = float64

GPflow/gpmc.py

@@ -21,6 +21,7 @@
 from .priors import Gaussian
 from .mean_functions import Zero
 from .tf_hacks import eye
+from ._settings import settings
 
 
 class GPMC(GPModel):
@@ -74,7 +75,7 @@ def build_likelihood(self):
 
         """
         K = self.kern.K(self.X)
-        L = tf.cholesky(K) + eye(tf.shape(self.X)[0])*1e-6
+        L = tf.cholesky(K + eye(tf.shape(self.X)[0])*settings.numerics.jitter_level)
         F = tf.matmul(L, self.V) + self.mean_function(self.X)
 
         return tf.reduce_sum(self.likelihood.logp(F, self.Y))

GPflow/model.py

@@ -19,6 +19,7 @@
 import numpy as np
 import tensorflow as tf
 from . import hmc, tf_hacks
+from ._settings import settings
 import sys
 
 
@@ -143,7 +144,8 @@ def _compile(self, optimizer=None):
         self._session.run(init)
 
         # build tensorflow functions for computing the likelihood
-        print("compiling tensorflow function...")
+        if settings.verbosity.tf_compile_verb:
+            print("compiling tensorflow function...")
         sys.stdout.flush()
 
         def obj(x):
@@ -153,7 +155,8 @@ def obj(x):
                                      feed_dict=feed_dict)
 
         self._objective = obj
-        print("done")
+        if settings.verbosity.tf_compile_verb:
+            print("done")
         sys.stdout.flush()
         self._needs_recompile = False
 
@@ -270,7 +273,7 @@ def _optimize_np(self, method='L-BFGS-B', tol=None, callback=None,
         if self._needs_recompile:
             self._compile()
 
-        options = dict(disp=True, maxiter=maxiter)
+        options = dict(disp=settings.verbosity.optimisation_verb, maxiter=maxiter)
         if 'max_iters' in kw:  # pragma: no cover
             options['maxiter'] = kw.pop('max_iters')
             import warnings
@@ -293,13 +296,14 @@ def _optimize_np(self, method='L-BFGS-B', tol=None, callback=None,
                               tol=tol,
                               callback=callback,
                               options=options)
-        except (KeyboardInterrupt):
+        except KeyboardInterrupt:
             print("Caught KeyboardInterrupt, setting \
                   model with most recent state.")
             self.set_state(obj._previous_x)
             return None
 
-        print("optimization terminated, setting model state")
+        if settings.verbosity.optimisation_verb:
+            print("optimization terminated, setting model state")
         self.set_state(result.x)
         return result
 
@@ -374,7 +378,7 @@ def predict_f_samples(self, Xnew, num_samples):
         Xnew.
         """
         mu, var = self.build_predict(Xnew, full_cov=True)
-        jitter = tf_hacks.eye(tf.shape(mu)[0]) * 1e-6
+        jitter = tf_hacks.eye(tf.shape(mu)[0]) * settings.numerics.jitter_level
         samples = []
         for i in range(self.num_latent):
             L = tf.cholesky(var[:, :, i] + jitter)

GPflow/sgpr.py

@@ -21,6 +21,7 @@
 from .mean_functions import Zero
 from . import likelihoods
 from .tf_hacks import eye
+from ._settings import settings
 
 
 class SGPR(GPModel):
@@ -73,7 +74,7 @@ def build_likelihood(self):
         err = self.Y - self.mean_function(self.X)
         Kdiag = self.kern.Kdiag(self.X)
         Kuf = self.kern.K(self.Z, self.X)
-        Kuu = self.kern.K(self.Z) + eye(num_inducing) * 1e-6
+        Kuu = self.kern.K(self.Z) + eye(num_inducing) * settings.numerics.jitter_level
         L = tf.cholesky(Kuu)
         sigma = tf.sqrt(self.likelihood.variance)
 
@@ -105,7 +106,7 @@ def build_predict(self, Xnew, full_cov=False):
         num_inducing = tf.shape(self.Z)[0]
         err = self.Y - self.mean_function(self.X)
         Kuf = self.kern.K(self.Z, self.X)
-        Kuu = self.kern.K(self.Z) + eye(num_inducing) * 1e-6
+        Kuu = self.kern.K(self.Z) + eye(num_inducing) * settings.numerics.jitter_level
         Kus = self.kern.K(self.Z, Xnew)
         sigma = tf.sqrt(self.likelihood.variance)
         L = tf.cholesky(Kuu)
@@ -170,7 +171,7 @@ def build_common_terms(self):
         err = self.Y - self.mean_function(self.X)  # size N x R
         Kdiag = self.kern.Kdiag(self.X)
         Kuf = self.kern.K(self.Z, self.X)
-        Kuu = self.kern.K(self.Z) + eye(num_inducing) * 1e-6
+        Kuu = self.kern.K(self.Z) + eye(num_inducing) * settings.numerics.jitter_level
 
         Luu = tf.cholesky(Kuu)  # => Luu^T Luu = Kuu
         V = tf.matrix_triangular_solve(Luu, Kuf)  # => V^T V = Qff

GPflow/svgp.py

@@ -21,6 +21,7 @@
 from . import transforms, conditionals, kullback_leiblers
 from .mean_functions import Zero
 from .tf_hacks import eye
+from ._settings import settings
 
 
 class MinibatchData(DataHolder):
@@ -111,7 +112,7 @@ def build_prior_KL(self):
             else:
                 KL = kullback_leiblers.gauss_kl_white(self.q_mu, self.q_sqrt)
         else:
-            K = self.kern.K(self.Z) + eye(self.num_inducing) * 1e-6
+            K = self.kern.K(self.Z) + eye(self.num_inducing) * settings.numerics.jitter_level
             if self.q_diag:
                 KL = kullback_leiblers.gauss_kl_diag(self.q_mu, self.q_sqrt, K)
             else:

testing/test_transforms.py

@@ -53,11 +53,11 @@ class TestLowerTriTransform(unittest.TestCase):
     """
     Some extra tests for the LowerTriangle transformation.
     """
+
     def setUp(self):
         self.t = GPflow.transforms.LowerTriangular(3)
 
     def testErrors(self):
-
         self.t.free_state_size((6, 6, 3))
         with self.assertRaises(ValueError):
             self.t.free_state_size((6, 6, 2))