Added option to turn off all logging

Author: lindonroberts

dfols/controller.py

@@ -92,12 +92,14 @@ def able_to_do_restart(self):
 
 
 class Controller(object):
-    def __init__(self, objfun, args, x0, r0, r0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes):
+    def __init__(self, objfun, args, x0, r0, r0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params,
+                 scaling_changes, do_logging):
+        self.do_logging = do_logging
         self.objfun = objfun
         self.args = args
         self.maxfun = maxfun
         self.model = Model(npt, x0, r0, xl, xu, r0_nsamples, precondition=params("interpolation.precondition"),
-                           abs_tol = params("model.abs_tol"), rel_tol = params("model.rel_tol"))
+                           abs_tol = params("model.abs_tol"), rel_tol = params("model.rel_tol"), do_logging=do_logging)
         self.nf = nf
         self.nx = nx
         self.rhobeg = rhobeg
@@ -131,7 +133,8 @@ def npt(self):
         return self.model.npt()
 
     def initialise_coordinate_directions(self, number_of_samples, num_directions, params):
-        logging.debug("Initialising with coordinate directions")
+        if self.do_logging:
+            logging.debug("Initialising with coordinate directions")
         # self.model already has x0 evaluated, so only need to initialise the other points
         # num_directions = params("growing.ndirs_initial")
         assert self.model.num_pts <= (self.n() + 1) * (self.n() + 2) // 2, "prelim: must have npt <= (n+1)(n+2)/2"
@@ -204,7 +207,8 @@ def initialise_coordinate_directions(self, number_of_samples, num_directions, pa
         return None   # return & continue
 
     def initialise_random_directions(self, number_of_samples, num_directions, params):
-        logging.debug("Initialising with random orthogonal directions")
+        if self.do_logging:
+            logging.debug("Initialising with random orthogonal directions")
         # self.model already has x0 evaluated, so only need to initialise the other points
         assert 1 <= num_directions < self.model.num_pts, "Initialisation: must have 1 <= ndirs_initial < npt"
 
@@ -331,14 +335,12 @@ def trust_region_step(self):
         return d, gopt, H, gnew, crvmin
 
     def geometry_step(self, knew, adelt, number_of_samples, params):
-        logging.debug("Running geometry-fixing step")
+        if self.do_logging:
+            logging.debug("Running geometry-fixing step")
         try:
             c, g = self.model.lagrange_gradient(knew)
             # c = 1.0 if knew == self.model.kopt else 0.0  # based at xopt, just like d
             # Solve problem: bounds are sl <= xnew <= su, and ||xnew-xopt|| <= adelt
-            logging.debug("xopt = %s" % str(self.model.xopt()))
-            logging.debug("sl = %s" % str(self.model.sl))
-            logging.debug("su = %s" % str(self.model.su))
             xnew = trsbox_geometry(self.model.xopt(), c, g, np.minimum(self.model.sl, 0.0), np.maximum(self.model.su, 0.0), adelt)
         except LA.LinAlgError:
             exit_info = ExitInformation(EXIT_LINALG_ERROR, "Singular matrix encountered in geometry step")
@@ -409,9 +411,11 @@ def evaluate_objective(self, x, number_of_samples, params):
             if not incremented_nx:
                 self.nx += 1
                 incremented_nx = True
-            rvec_list[i, :], f_list[i] = eval_least_squares_objective(self.objfun, remove_scaling(x, self.scaling_changes), args=self.args, eval_num=self.nf, pt_num=self.nx,
+            rvec_list[i, :], f_list[i] = eval_least_squares_objective(self.objfun, remove_scaling(x, self.scaling_changes),
+                                            args=self.args, eval_num=self.nf, pt_num=self.nx,
                                             full_x_thresh=params("logging.n_to_print_whole_x_vector"),
-                                            check_for_overflow=params("general.check_objfun_for_overflow"))
+                                            check_for_overflow=params("general.check_objfun_for_overflow"),
+                                            verbose=self.do_logging)
             num_samples_run += 1
 
         # Check if the average value was below our threshold
@@ -524,11 +528,13 @@ def terminate_from_slow_iterations(self, current_iter, params):
         # Update counter of number of slow iterations
         if this_iter_slow:
             self.num_slow_iters += 1
-            logging.info("Slow iteration (%g consecutive so far, max allowed %g)"
-                         % (self.num_slow_iters, params("slow.max_slow_iters")))
+            if self.do_logging:
+                logging.info("Slow iteration (%g consecutive so far, max allowed %g)"
+                             % (self.num_slow_iters, params("slow.max_slow_iters")))
         else:
             self.num_slow_iters = 0
-            logging.debug("Non-slow iteration")
+            if self.do_logging:
+                logging.debug("Non-slow iteration")
         return this_iter_slow, self.num_slow_iters >= params("slow.max_slow_iters")
 
     def soft_restart(self, number_of_samples, nruns_so_far, params, x_in_abs_coords_to_save=None, rvec_to_save=None,
@@ -556,7 +562,8 @@ def soft_restart(self, number_of_samples, nruns_so_far, params, x_in_abs_coords_
         self.model.save_point(self.model.xopt(abs_coordinates=True), self.model.ropt(),
                               self.model.nsamples[self.model.kopt], x_in_abs_coords=True)
 
-        logging.info("Soft restart [currently, f = %g after %g function evals]" % (self.model.fopt(), self.nf))
+        if self.do_logging:
+            logging.info("Soft restart [currently, f = %g after %g function evals]" % (self.model.fopt(), self.nf))
         # Resetting method: reset delta and rho, then move the closest 'num_steps' points to xk to improve geometry
         # Note: closest points because we are suddenly increasing delta & rho, so we want to encourage spreading out points
         self.delta = self.rhobeg
@@ -607,7 +614,8 @@ def soft_restart(self, number_of_samples, nruns_so_far, params, x_in_abs_coords_
                 for i in range(1, num_samples_run):
                     self.model.add_new_sample(self.model.npt() - 1, rvec_extra=rvec_list[i, :])
 
-            logging.info("Soft restart: added %g new directions, npt is now %g" % (num_pts_to_add, self.model.npt()))
+            if self.do_logging:
+                logging.info("Soft restart: added %g new directions, npt is now %g" % (num_pts_to_add, self.model.npt()))
 
         # Otherwise, we are doing a restart
         self.last_successful_iter = 0

dfols/model.py

@@ -41,7 +41,8 @@
 __all__ = ['Model']
 
 class Model(object):
-    def __init__(self, npt, x0, r0, xl, xu, r0_nsamples, n=None, m=None, abs_tol=1e-12, rel_tol=1e-20, precondition=True):
+    def __init__(self, npt, x0, r0, xl, xu, r0_nsamples, n=None, m=None, abs_tol=1e-12, rel_tol=1e-20, precondition=True,
+                 do_logging=True):
         if n is None:
             n = len(x0)
         if m is None:
@@ -51,6 +52,7 @@ def __init__(self, npt, x0, r0, xl, xu, r0_nsamples, n=None, m=None, abs_tol=1e-
         assert xl.shape == (n,), "xl has wrong shape (got %s, expect (%g,))" % (str(xl.shape), n)
         assert xu.shape == (n,), "xu has wrong shape (got %s, expect (%g,))" % (str(xu.shape), n)
         assert r0.shape == (m,), "r0 has wrong shape (got %s, expect (%g,))" % (str(r0.shape), m)
+        self.do_logging = do_logging
         self.dim = n
         self.resid_dim = m
         self.num_pts = npt
@@ -298,7 +300,8 @@ def solve_geom_system(self, rhs):
                 Qb = np.dot(self.Q.T, col_scale(rhs, self.left_scaling))
                 return col_scale(LA.solve_triangular(self.R, Qb), self.right_scaling)
         else:
-            logging.warning("model.solve_geom_system not using factorisation")
+            if self.do_logging:
+                logging.warning("model.solve_geom_system not using factorisation")
             W, left_scaling, right_scaling = self.interpolation_matrix()
             return col_scale(LA.lstsq(W, col_scale(rhs * left_scaling))[0], right_scaling)