Optionally turn off logging or turn on per-iteration info, drop random seed from example scripts (no longer needed by default)

Author: lindonroberts

examples/global_opt_demo.py

@@ -23,9 +23,6 @@ def freudenstein_roth(x):
 lower = np.array([-30.0, -30.0])
 upper = np.array([30.0, 30.0])
 
-# Set random seed (for reproducibility)
-np.random.seed(0)
-
 print("First run - search for local minimum only")
 print("")
 soln = pybobyqa.solve(freudenstein_roth, x0, maxfun=500, bounds=(lower, upper))

examples/rosenbrock_basic.py

@@ -10,9 +10,6 @@ def rosenbrock(x):
 # Define the starting point
 x0 = np.array([-1.2, 1.0])
 
-# Set random seed (for reproducibility)
-np.random.seed(0)
-
 # For optional extra output details
 # import logging
 # logging.basicConfig(level=logging.INFO, format='%(message)s')

examples/rosenbrock_bounds.py

@@ -10,9 +10,6 @@ def rosenbrock(x):
 # Define the starting point
 x0 = np.array([-1.2, 1.0])
 
-# Set random seed (for reproducibility)
-np.random.seed(0)
-
 # Define bound constraints (lower <= x <= upper)
 lower = np.array([-10.0, -10.0])
 upper = np.array([0.9, 0.85])

pybobyqa/controller.py

@@ -92,12 +92,12 @@ def able_to_do_restart(self):
 
 
 class Controller(object):
-    def __init__(self, objfun, x0, args, f0, f0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes):
+    def __init__(self, objfun, x0, args, f0, f0_nsamples, xl, xu, npt, rhobeg, rhoend, nf, nx, maxfun, params, scaling_changes, do_logging=True):
         self.objfun = objfun
         self.maxfun = maxfun
         self.args = args
         self.model = Model(npt, x0, f0, xl, xu, f0_nsamples, abs_tol=params("model.abs_tol"),
-                           precondition=params("interpolation.precondition"))
+                           precondition=params("interpolation.precondition"), do_logging=do_logging)
         self.nf = nf
         self.nx = nx
         self.rhobeg = rhobeg
@@ -121,6 +121,7 @@ def __init__(self, objfun, x0, args, f0, f0_nsamples, xl, xu, npt, rhobeg, rhoen
         self.total_unsuccessful_restarts = 0
         self.last_run_fopt = f0
         self.scaling_changes = scaling_changes
+        self.do_logging = do_logging
 
     def n(self):
         return self.model.n()
@@ -129,7 +130,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"
@@ -202,7 +204,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
         # num_directions = params("growing.ndirs_initial")
         assert 1 <= num_directions < self.model.num_pts, "Initialisation: must have 1 <= ndirs_initial < npt"
@@ -270,7 +273,8 @@ 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, H = self.model.lagrange_polynomial(knew)  # based at xopt
             # Solve problem: bounds are sl <= xnew <= su, and ||xnew-xopt|| <= adelt
@@ -344,7 +348,8 @@ def evaluate_objective(self, x, number_of_samples, params):
                 incremented_nx = True
             f_list[i] = eval_objective(self.objfun, remove_scaling(x, self.scaling_changes), 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
@@ -453,11 +458,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)"
+            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, f_to_save=None,
@@ -491,7 +498,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.fopt(),
                               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

pybobyqa/model.py

@@ -42,7 +42,7 @@
 
 
 class Model(object):
-    def __init__(self, npt, x0, f0, xl, xu, f0_nsamples, n=None, abs_tol=-1e20, precondition=True):
+    def __init__(self, npt, x0, f0, xl, xu, f0_nsamples, n=None, abs_tol=-1e20, precondition=True, do_logging=True):
         if n is None:
             n = len(x0)
         assert npt >= n + 1, "Require npt >= n+1 for quadratic models"
@@ -52,6 +52,7 @@ def __init__(self, npt, x0, f0, xl, xu, f0_nsamples, n=None, abs_tol=-1e20, prec
         assert xu.shape == (n,), "xu has wrong shape (got %s, expect (%g,))" % (str(xu.shape), n)
         self.dim = n
         self.num_pts = npt
+        self.do_logging = do_logging
 
         # Initialise to blank some useful stuff
         # Interpolation points
@@ -258,7 +259,8 @@ def solve_system(self, rhs):
             # Solve A(original)\rhs
             return col_scale(LA.lu_solve((self.lu, self.piv), col_scale(rhs, self.left_scaling)), self.right_scaling)
         else:
-            logging.warning("model.solve_system not using factorisation")
+            if self.do_logging:
+                logging.warning("model.solve_system not using factorisation")
             A, left_scaling, right_scaling = self.interpolation_matrix()
             return col_scale(LA.solve(A, col_scale(rhs, left_scaling)), right_scaling)