Merge pull request #371 from bwheelz36/master

possible fix for #370

Author: bwheelz36

bayes_opt/bayesian_optimization.py

@@ -1,5 +1,4 @@
 import warnings
-from queue import Queue, Empty
 
 from bayes_opt.constraint import ConstraintModel
 
@@ -12,6 +11,29 @@
 from sklearn.gaussian_process import GaussianProcessRegressor
 
 
+class Queue:
+    def __init__(self):
+        self._queue = []
+
+    @property
+    def empty(self):
+        return len(self) == 0
+
+    def __len__(self):
+        return len(self._queue)
+
+    def __next__(self):
+        if self.empty:
+            raise StopIteration("Queue is empty, no more objects to retrieve.")
+        obj = self._queue[0]
+        self._queue = self._queue[1:]
+        return obj
+
+    def add(self, obj):
+        """Add object to end of queue."""
+        self._queue.append(obj)
+
+
 class Observable(object):
     """
 
@@ -173,7 +195,7 @@ def probe(self, params, lazy=True):
         """
 
         if lazy:
-            self._queue.put(params)
+            self._queue.add(params)
         else:
             self._space.probe(params)
             self.dispatch(Events.OPTIMIZATION_STEP)
@@ -204,11 +226,11 @@ def suggest(self, utility_function):
 
     def _prime_queue(self, init_points):
         """Make sure there's something in the queue at the very beginning."""
-        if self._queue.empty() and self._space.empty:
+        if self._queue.empty and self._space.empty:
             init_points = max(init_points, 1)
 
         for _ in range(init_points):
-            self._queue.put(self._space.random_sample())
+            self._queue.add(self._space.random_sample())
 
     def _prime_subscriptions(self):
         if not any([len(subs) for subs in self._events.values()]):
@@ -273,10 +295,10 @@ def maximize(self,
                                kappa_decay=kappa_decay,
                                kappa_decay_delay=kappa_decay_delay)
         iteration = 0
-        while not self._queue.empty() or iteration < n_iter:
+        while not self._queue.empty or iteration < n_iter:
             try:
-                x_probe = self._queue.get(block=False)
-            except Empty:
+                x_probe = next(self._queue)
+            except StopIteration:
                 util.update_params()
                 x_probe = self.suggest(util)
                 iteration += 1

tests/test_bayesian_optimization.py

@@ -4,7 +4,8 @@
 from bayes_opt import BayesianOptimization
 from bayes_opt.logger import ScreenLogger
 from bayes_opt.event import Events, DEFAULT_EVENTS
-
+import pickle
+import os
 
 def target_func(**kwargs):
     # arbitrary target func
@@ -37,35 +38,35 @@ def test_probe_lazy():
 
     optimizer.probe(params={"p1": 1, "p2": 2}, lazy=True)
     assert len(optimizer.space) == 0
-    assert optimizer._queue.qsize() == 1
+    assert len(optimizer._queue) == 1
 
     optimizer.probe(params={"p1": 6, "p2": 2}, lazy=True)
     assert len(optimizer.space) == 0
-    assert optimizer._queue.qsize() == 2
+    assert len(optimizer._queue) == 2
 
     optimizer.probe(params={"p1": 6, "p2": 2}, lazy=True)
     assert len(optimizer.space) == 0
-    assert optimizer._queue.qsize() == 3
+    assert len(optimizer._queue) == 3
 
 
 def test_probe_eager():
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
 
     optimizer.probe(params={"p1": 1, "p2": 2}, lazy=False)
     assert len(optimizer.space) == 1
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert optimizer.max["target"] == 3
     assert optimizer.max["params"] == {"p1": 1, "p2": 2}
 
     optimizer.probe(params={"p1": 3, "p2": 3}, lazy=False)
     assert len(optimizer.space) == 2
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert optimizer.max["target"] == 6
     assert optimizer.max["params"] == {"p1": 3, "p2": 3}
 
     optimizer.probe(params={"p1": 3, "p2": 3}, lazy=False)
     assert len(optimizer.space) == 2
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert optimizer.max["target"] == 6
     assert optimizer.max["params"] == {"p1": 3, "p2": 3}
 
@@ -101,43 +102,43 @@ def test_suggest_with_one_observation():
 
 def test_prime_queue_all_empty():
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert len(optimizer.space) == 0
 
     optimizer._prime_queue(init_points=0)
-    assert optimizer._queue.qsize() == 1
+    assert len(optimizer._queue) == 1
     assert len(optimizer.space) == 0
 
 
 def test_prime_queue_empty_with_init():
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert len(optimizer.space) == 0
 
     optimizer._prime_queue(init_points=5)
-    assert optimizer._queue.qsize() == 5
+    assert len(optimizer._queue) == 5
     assert len(optimizer.space) == 0
 
 
 def test_prime_queue_with_register():
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert len(optimizer.space) == 0
 
     optimizer.register(params={"p1": 1, "p2": 2}, target=3)
     optimizer._prime_queue(init_points=0)
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert len(optimizer.space) == 1
 
 
 def test_prime_queue_with_register_and_init():
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    assert optimizer._queue.empty()
+    assert len(optimizer._queue) == 0
     assert len(optimizer.space) == 0
 
     optimizer.register(params={"p1": 1, "p2": 2}, target=3)
     optimizer._prime_queue(init_points=3)
-    assert optimizer._queue.qsize() == 3
+    assert len(optimizer._queue) == 3
     assert len(optimizer.space) == 1
 
 
@@ -270,22 +271,22 @@ def reset(self):
     )
 
     optimizer.maximize(init_points=0, n_iter=0)
-    assert optimizer._queue.empty()
+    assert optimizer._queue.empty
     assert len(optimizer.space) == 1
     assert tracker.start_count == 1
     assert tracker.step_count == 1
     assert tracker.end_count == 1
 
     optimizer.maximize(init_points=2, n_iter=0, alpha=1e-2)
-    assert optimizer._queue.empty()
+    assert optimizer._queue.empty
     assert len(optimizer.space) == 3
     assert optimizer._gp.alpha == 1e-2
     assert tracker.start_count == 2
     assert tracker.step_count == 3
     assert tracker.end_count == 2
 
     optimizer.maximize(init_points=0, n_iter=2)
-    assert optimizer._queue.empty()
+    assert optimizer._queue.empty
     assert len(optimizer.space) == 5
     assert tracker.start_count == 3
     assert tracker.step_count == 5
@@ -320,6 +321,21 @@ def test_single_value_objective():
     )
 
 
+def test_pickle():
+    """
+    several users have asked that the BO object be 'pickalable'
+    This tests that this is the case
+    """
+    optimizer = BayesianOptimization(
+        f=None,
+        pbounds={'x': (-10, 10)},
+        verbose=2,
+        random_state=1,
+    )
+    with open("test_dump.obj", "wb") as filehandler:
+        pickle.dump(optimizer, filehandler)
+    os.remove('test_dump.obj')
+
 if __name__ == '__main__':
     r"""
     CommandLine:

tests/test_queue.py

@@ -1,42 +1,43 @@
 import pytest
-from queue import Queue, Empty
+from bayes_opt.bayesian_optimization import Queue
 
 
 def test_add():
     queue = Queue()
 
-    assert queue.empty()
+    assert len(queue) == 0
+    assert queue.empty
 
-    queue.put(1)
-    assert queue.qsize() == 1
+    queue.add(1)
+    assert len(queue) == 1
 
-    queue.put(1)
-    assert queue.qsize() == 2
+    queue.add(1)
+    assert len(queue) == 2
 
-    queue.put(2)
-    assert queue.qsize() == 3
+    queue.add(2)
+    assert len(queue) == 3
 
 
 def test_queue():
 
     queue = Queue()
 
-    with pytest.raises(Empty):
-        queue.get(block=False)
+    with pytest.raises(StopIteration):
+        next(queue)
 
-    queue.put(1)
-    queue.put(2)
-    queue.put(3)
+    queue.add(1)
+    queue.add(2)
+    queue.add(3)
 
-    assert queue.qsize() == 3
-    assert not queue.empty()
+    assert len(queue) == 3
+    assert not queue.empty
 
-    assert queue.get() == 1
-    assert queue.qsize() == 2
+    assert next(queue) == 1
+    assert len(queue) == 2
 
-    assert queue.get() == 2
-    assert queue.get() == 3
-    assert queue.empty()
+    assert next(queue) == 2
+    assert next(queue) == 3
+    assert len(queue) == 0