Introduce default printer and json observers

This commit refactors heavily how loggin is done in the package. It
removes the old style of loggin and does everything now using observers.
By default the user has access to two useful observers, json and
printer, and if the users doesn't want to deal with that the verbose
parameter takes care of the basics.

Author: fmfn

bayes_opt/__init__.py

@@ -1,5 +1,5 @@
 from .bayesian_optimization import BayesianOptimization, Events
-from .helpers import UtilityFunction
-from .observer import Observer
+from .util import UtilityFunction
+from .observer import ScreenLogger
 
-__all__ = ["BayesianOptimization", "UtilityFunction", "Events", "Observer"]
+__all__ = ["BayesianOptimization", "UtilityFunction", "Events", "ScreenLogger"]

bayes_opt/bayesian_optimization.py

@@ -2,8 +2,9 @@
 import numpy as np
 
 from .target_space import TargetSpace
-from .observer import Observable, Events
-from .helpers import UtilityFunction, acq_max, ensure_rng
+from .event import Events, DEFAULT_EVENTS
+from .observer import _get_default_logger
+from .util import UtilityFunction, acq_max, ensure_rng
 
 from sklearn.gaussian_process.kernels import Matern
 from sklearn.gaussian_process import GaussianProcessRegressor
@@ -22,7 +23,7 @@ def __len__(self):
 
     def __next__(self):
         if self.empty:
-            raise ValueError("Cannot retrieve next object from empty queue.")
+            raise StopIteration("Queue is empty, no more objects to retrieve.")
         obj = self._queue[0]
         self._queue = self._queue[1:]
         return obj
@@ -32,6 +33,33 @@ def add(self, obj):
         self._queue.append(obj)
 
 
+class Observable:
+    """
+
+    Inspired/Taken from
+        https://www.protechtraining.com/blog/post/879#simple-observer
+    """
+    def __init__(self, events):
+        # maps event names to subscribers
+        # str -> dict
+        self._events = {event: dict() for event in events}
+
+    def get_subscribers(self, event):
+        return self._events[event]
+
+    def subscribe(self, event, subscriber, callback=None):
+        if callback == None:
+            callback = getattr(subscriber, 'update')
+        self.get_subscribers(event)[subscriber] = callback
+
+    def unsubscribe(self, event, subscriber):
+        del self.get_subscribers(event)[subscriber]
+
+    def dispatch(self, event):
+        for _, callback in self.get_subscribers(event).items():
+            callback(event, self)
+
+
 class BayesianOptimization(Observable):
     def __init__(self, f, pbounds, random_state=None, verbose=1):
         """"""
@@ -53,7 +81,8 @@ def __init__(self, f, pbounds, random_state=None, verbose=1):
             random_state=self._random_state,
         )
 
-        super(BayesianOptimization, self).__init__(events=None)
+        self._verbose = verbose
+        super(BayesianOptimization, self).__init__(events=DEFAULT_EVENTS)
 
     @property
     def space(self):
@@ -80,6 +109,9 @@ def probe(self, x, lazy=True):
 
     def suggest(self, utility_function):
         """Most promissing point to probe next"""
+        if len(self._space) == 0:
+            return self._space.array_to_params(self._space.random_sample())
+
         # Sklearn's GP throws a large number of warnings at times, but
         # we don't really need to see them here.
         with warnings.catch_warnings():
@@ -105,6 +137,13 @@ def _prime_queue(self, init_points):
         for _ in range(init_points):
             self._queue.add(self._space.random_sample())
 
+    def _prime_subscriptions(self):
+        if not any([len(subs) for subs in self._events.values()]):
+            _logger = _get_default_logger(self._verbose)
+            self.subscribe(Events.OPTMIZATION_START, _logger)
+            self.subscribe(Events.OPTMIZATION_STEP, _logger)
+            self.subscribe(Events.OPTMIZATION_END, _logger)
+
     def maximize(self,
                  init_points: int=5,
                  n_iter: int=25,
@@ -113,21 +152,24 @@ def maximize(self,
                  xi: float=0.0,
                  **gp_params):
         """Mazimize your function"""
+        self._prime_subscriptions()
+        self.dispatch(Events.OPTMIZATION_START)
         self._prime_queue(init_points)
 
         util = UtilityFunction(kind=acq, kappa=kappa, xi=xi)
         iteration = 0
         while not self._queue.empty or iteration < n_iter:
             try:
                 x_probe = next(self._queue)
-            except ValueError:
+            except StopIteration:
                 x_probe = self.suggest(util)
                 iteration += 1
 
             self.probe(x_probe, lazy=False)
+            self.dispatch(Events.OPTMIZATION_STEP)
 
         # Notify about finished optimization
-        self.dispatch(Events.FIT_DONE)
+        self.dispatch(Events.OPTMIZATION_END)
 
     def set_bounds(self, new_bounds):
         """

bayes_opt/event.py

@@ -0,0 +1,19 @@
+class Events:
+    OPTMIZATION_START = 'optmization:start'
+    OPTMIZATION_STEP = 'optmization:step'
+    OPTMIZATION_END = 'optmization:end'
+
+    PROBE_FROM_SUGGESTION = "probe:suggestion"
+    PROBE_FROM_QUEUE = "probe:queue"
+
+    ELEMENT_ADDED_TO_QUEUE = ""
+    QUEUE_IS_EMPTY = ""
+
+
+DEFAULT_EVENTS = [
+    Events.OPTMIZATION_START,
+    Events.OPTMIZATION_STEP,
+    Events.OPTMIZATION_END,
+    Events.ELEMENT_ADDED_TO_QUEUE,
+    Events.QUEUE_IS_EMPTY,
+]

bayes_opt/observer.py

@@ -1,57 +1,163 @@
 """
+observers...
+"""
+import os
+import json
+from datetime import datetime
 
+from .event import Events
+from .util import Colours
+
+
+class _Tracker:
+    def __init__(self):
+        self._iterations = 0
+
+        self._previous_max = None
+        self._previous_max_params = None
+
+        self._start_time = None
+        self._previous_time = None
+
+    def _update_tracker(self, event, instance):
+        if event == Events.OPTMIZATION_STEP:
+            self._iterations += 1
+
+            current_max = instance.max
+            if (self._previous_max is None or
+                current_max["target"] > self._previous_max):
+                self._previous_max = current_max["target"]
+                self._previous_max_params = current_max["params"]
+
+    def _time_metrics(self):
+        now = datetime.now()
+        if self._start_time is None:
+            self._start_time = now
+        if self._previous_time is None:
+            self._previous_time = now
+
+        time_elapsed = now - self._start_time
+        time_delta = now - self._previous_time
+
+        self._previous_time = now
+        return (
+            now.strftime("%Y-%m-%d %H:%M:%S"),
+            time_elapsed.total_seconds(),
+            time_delta.total_seconds()
+        )
 
-Inspired/Taken from https://www.protechtraining.com/blog/post/879#simple-observer
-"""
 
+def _get_default_logger(verbose):
+    return ScreenLogger(verbose=verbose)
 
-class Events(object):
-    INIT_DONE = 'initialized'
-    FIT_STEP_DONE = 'fit_step_done'
-    FIT_DONE = 'fit_done'
 
+class ScreenLogger(_Tracker):
+    _default_cell_size = 9
+    _default_precision = 4
 
-DEFAULT_EVENTS = [
-    Events.INIT_DONE,
-    Events.FIT_STEP_DONE,
-    Events.FIT_DONE
-]
+    def __init__(self, verbose=0):
+        self._verbose = verbose
+        self._header_length = None
+        super(ScreenLogger, self).__init__()
 
+    @property
+    def verbose(self):
+        return self._verbose
 
-class Observable(object):
-    def __init__(self, events=None):
-        # maps event names to subscribers
-        # str -> dict
-        if events is None:
-            events = DEFAULT_EVENTS
+    @verbose.setter
+    def verbose(self, v):
+        self._verbose = v
 
-        self.events = {event: dict() for event in events}
+    def _format_number(self, x):
+        if isinstance(x, int):
+                s = "{x:< {s}}".format(
+                    x=x,
+                    s=self._default_cell_size,
+                )
+        else:
+            s = "{x:< {s}.{p}}".format(
+                x=x,
+                s=self._default_cell_size,
+                p=self._default_precision,
+            )
 
-    def get_subscribers(self, event):
-        return self.events[event]
+        if len(s) > self._default_cell_size:
+            if "." in s:
+                return s[:self._default_cell_size]
+            else:
+                return s[:self._default_cell_size - 3] + "..."
+        return s
 
-    def register(self, event, who, callback=None):
-        if callback == None:
-            callback = getattr(who, 'update')
-        self.get_subscribers(event)[who] = callback
+    def _format_key(self, key):
+        s = "{key:^{s}}".format(
+            key=key,
+            s=self._default_cell_size
+        )
+        if len(s) > self._default_cell_size:
+            return s[:self._default_cell_size - 3] + "..."
+        return s
 
-    def unregister(self, event, who):
-        del self.get_subscribers(event)[who]
+    def _step(self, instance, colour=Colours.black):
+        res = instance.res[-1]
+        cells = []
 
-    def dispatch(self, event):
-        for subscriber, callback in self.get_subscribers(event).items():
-            callback(event, self)
+        cells.append(self._format_number(self._iterations))
+        cells.append(self._format_number(res["target"]))
 
+        for val in res["params"].values():
+            cells.append(self._format_number(val))
+
+        return "| " + " | ".join(map(colour, cells)) + " |"
+
+    def _header(self, instance):
+        cells = []
+        cells.append(self._format_key("iter"))
+        cells.append(self._format_key("target"))
+        for key in instance.space.keys:
+            cells.append(self._format_key(key))
+
+        line = "| " + " | ".join(cells) + " |"
+        self._header_length = len(line)
+        return line + "\n" + ("-" * self._header_length)
+
+    def update(self, event, instance):
+        if event == Events.OPTMIZATION_START:
+            line = self._header(instance)
+        elif event == Events.OPTMIZATION_STEP:
+            colour = (
+                Colours.purple if
+                self._previous_max is None or
+                instance.max["target"] > self._previous_max else
+                Colours.black
+            )
+            line = self._step(instance, colour=colour)
+        elif event == Events.OPTMIZATION_END:
+            line = "=" * self._header_length
+
+        print(line)
+        self._update_tracker(event, instance)
+
+class JSONLogger(_Tracker):
+    def __init__(self, path):
+        self._path = path if path[-5:] == ".json" else path + ".json"
+        try:
+            os.remove(self._path)
+        except OSError:
+            pass
+        super(JSONLogger, self).__init__()
 
-class Observer:
     def update(self, event, instance):
-        # Avoid circular import
-        from .bayesian_optimization import Events
-        if event is Events.INIT_DONE:
-            print("Initialization completed")
-        elif event is Events.FIT_STEP_DONE:
-            print("Optimization step finished, current max: ",
-                  instance.res['max'])
-        elif event is Events.FIT_DONE:
-            print("Optimization finished, maximum value at: ",
-                  instance.res['max'])
+        if event == Events.OPTMIZATION_STEP:
+            data = dict(instance.res[-1])
+
+            now, time_elapsed, time_delta = self._time_metrics()
+            data["datetime"] = {
+                "datetime": now,
+                "elapsed": time_elapsed,
+                "delta": time_delta,
+            }
+
+            with open(self._path, "a") as f:
+                f.write(json.dumps(data) + "\n")
+
+        self._update_tracker(event, instance)

bayes_opt/target_space.py

@@ -1,6 +1,5 @@
-from __future__ import print_function, division
 import numpy as np
-from .helpers import ensure_rng, unique_rows
+from .util import ensure_rng, unique_rows
 
 
 def _hashable(x):
@@ -226,7 +225,7 @@ def res(self):
         params = [dict(zip(self.keys, p)) for p in self.x]
 
         return [
-            {"target": target, "param": param}
+            {"target": target, "params": param}
             for target, param in zip(self.target, params)
         ]