fix typo, OPTMIZATION -> OPTIMIZATION

Author: murbard

README.md

@@ -235,7 +235,7 @@ The `BayesianOptimization` object fires a number of internal events during optim
 
 ```python
 logger = JSONLogger(path="./logs.json")
-optimizer.subscribe(Events.OPTMIZATION_STEP, logger)
+optimizer.subscribe(Events.OPTIMIZATION_STEP, logger)
 
 # Results will be saved in ./logs.json
 optimizer.maximize(

bayes_opt/bayesian_optimization.py

@@ -102,15 +102,15 @@ def res(self):
     def register(self, params, target):
         """Expect observation with known target"""
         self._space.register(params, target)
-        self.dispatch(Events.OPTMIZATION_STEP)
+        self.dispatch(Events.OPTIMIZATION_STEP)
 
     def probe(self, params, lazy=True):
         """Probe target of x"""
         if lazy:
             self._queue.add(params)
         else:
             self._space.probe(params)
-            self.dispatch(Events.OPTMIZATION_STEP)
+            self.dispatch(Events.OPTIMIZATION_STEP)
 
     def suggest(self, utility_function):
         """Most promissing point to probe next"""
@@ -145,9 +145,9 @@ def _prime_queue(self, init_points):
     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)
+            self.subscribe(Events.OPTIMIZATION_START, _logger)
+            self.subscribe(Events.OPTIMIZATION_STEP, _logger)
+            self.subscribe(Events.OPTIMIZATION_END, _logger)
 
     def maximize(self,
                  init_points=5,
@@ -158,7 +158,7 @@ def maximize(self,
                  **gp_params):
         """Mazimize your function"""
         self._prime_subscriptions()
-        self.dispatch(Events.OPTMIZATION_START)
+        self.dispatch(Events.OPTIMIZATION_START)
         self._prime_queue(init_points)
         self.set_gp_params(**gp_params)
 
@@ -173,7 +173,7 @@ def maximize(self,
 
             self.probe(x_probe, lazy=False)
 
-        self.dispatch(Events.OPTMIZATION_END)
+        self.dispatch(Events.OPTIMIZATION_END)
 
     def set_bounds(self, new_bounds):
         """

bayes_opt/event.py

@@ -1,11 +1,11 @@
 class Events:
-    OPTMIZATION_START = 'optmization:start'
-    OPTMIZATION_STEP = 'optmization:step'
-    OPTMIZATION_END = 'optmization:end'
+    OPTIMIZATION_START = 'optimization:start'
+    OPTIMIZATION_STEP = 'optimization:step'
+    OPTIMIZATION_END = 'optimization:end'
 
 
 DEFAULT_EVENTS = [
-    Events.OPTMIZATION_START,
-    Events.OPTMIZATION_STEP,
-    Events.OPTMIZATION_END,
+    Events.OPTIMIZATION_START,
+    Events.OPTIMIZATION_STEP,
+    Events.OPTIMIZATION_END,
 ]

bayes_opt/logger.py

@@ -86,16 +86,16 @@ def _is_new_max(self, instance):
         return instance.max["target"] > self._previous_max
 
     def update(self, event, instance):
-        if event == Events.OPTMIZATION_START:
+        if event == Events.OPTIMIZATION_START:
             line = self._header(instance) + "\n"
-        elif event == Events.OPTMIZATION_STEP:
+        elif event == Events.OPTIMIZATION_STEP:
             is_new_max = self._is_new_max(instance)
             if self._verbose == 1 and not is_new_max:
                 line = ""
             else:
                 colour = Colours.purple if is_new_max else Colours.black
                 line = self._step(instance, colour=colour) + "\n"
-        elif event == Events.OPTMIZATION_END:
+        elif event == Events.OPTIMIZATION_END:
             line = "=" * self._header_length + "\n"
 
         if self._verbose:
@@ -113,7 +113,7 @@ def __init__(self, path):
         super(JSONLogger, self).__init__()
 
     def update(self, event, instance):
-        if event == Events.OPTMIZATION_STEP:
+        if event == Events.OPTIMIZATION_STEP:
             data = dict(instance.res[-1])
 
             now, time_elapsed, time_delta = self._time_metrics()

bayes_opt/observer.py

@@ -21,7 +21,7 @@ def __init__(self):
         self._previous_time = None
 
     def _update_tracker(self, event, instance):
-        if event == Events.OPTMIZATION_STEP:
+        if event == Events.OPTIMIZATION_STEP:
             self._iterations += 1
 
             current_max = instance.max

examples/advanced-tour.ipynb

@@ -427,7 +427,7 @@
     "my_observer = BasicObserver()\n",
     "\n",
     "optimizer.subscribe(\n",
-    "    event=Events.OPTMIZATION_STEP,\n",
+    "    event=Events.OPTIMIZATION_STEP,\n",
     "    subscriber=my_observer,\n",
     "    callback=None, # Will use the `update` method as callback\n",
     ")"
@@ -450,7 +450,7 @@
     "    print(\"Go nuts here!\")\n",
     "\n",
     "optimizer.subscribe(\n",
-    "    event=Events.OPTMIZATION_START,\n",
+    "    event=Events.OPTIMIZATION_START,\n",
     "    subscriber=\"Any hashable object\",\n",
     "    callback=my_callback,\n",
     ")"
@@ -466,9 +466,9 @@
      "output_type": "stream",
      "text": [
       "Go nuts here!\n",
-      "Event `optmization:step` was observed\n",
-      "Event `optmization:step` was observed\n",
-      "Event `optmization:step` was observed\n"
+      "Event `optimization:step` was observed\n",
+      "Event `optimization:step` was observed\n",
+      "Event `optimization:step` was observed\n"
      ]
     }
    ],
@@ -491,7 +491,7 @@
     {
      "data": {
       "text/plain": [
-       "['optmization:start', 'optmization:step', 'optmization:end']"
+       "['optimization:start', 'optimization:step', 'optimization:end']"
       ]
      },
      "execution_count": 20,

examples/basic-tour.ipynb

@@ -346,7 +346,7 @@
    "outputs": [],
    "source": [
     "logger = JSONLogger(path=\"./logs.json\")\n",
-    "optimizer.subscribe(Events.OPTMIZATION_STEP, logger)"
+    "optimizer.subscribe(Events.OPTIMIZATION_STEP, logger)"
    ]
   },
   {

tests/test_bayesian_optimization.py

@@ -162,33 +162,33 @@ def test_callback(event, instance):
 
     optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
     optimizer.subscribe(
-        event=Events.OPTMIZATION_START,
+        event=Events.OPTIMIZATION_START,
         subscriber=test_subscriber,
         callback=test_callback,
     )
     # Test that the desired observer is subscribed
     assert all([
         k == test_subscriber for k in
-        optimizer._events[Events.OPTMIZATION_START].keys()
+        optimizer._events[Events.OPTIMIZATION_START].keys()
     ])
     assert all([
         v == test_callback for v in
-        optimizer._events[Events.OPTMIZATION_START].values()
+        optimizer._events[Events.OPTIMIZATION_START].values()
     ])
 
     # Check that prime subscriptions won't overight manual subscriptions
     optimizer._prime_subscriptions()
     assert all([
         k == test_subscriber for k in
-        optimizer._events[Events.OPTMIZATION_START].keys()
+        optimizer._events[Events.OPTIMIZATION_START].keys()
     ])
     assert all([
         v == test_callback for v in
-        optimizer._events[Events.OPTMIZATION_START].values()
+        optimizer._events[Events.OPTIMIZATION_START].values()
     ])
 
-    assert optimizer._events[Events.OPTMIZATION_STEP] == {}
-    assert optimizer._events[Events.OPTMIZATION_END] == {}
+    assert optimizer._events[Events.OPTIMIZATION_STEP] == {}
+    assert optimizer._events[Events.OPTIMIZATION_END] == {}
 
     with pytest.raises(KeyError):
         optimizer._events["other"]
@@ -253,17 +253,17 @@ def reset(self):
 
     tracker = Tracker()
     optimizer.subscribe(
-        event=Events.OPTMIZATION_START,
+        event=Events.OPTIMIZATION_START,
         subscriber=tracker,
         callback=tracker.update_start,
     )
     optimizer.subscribe(
-        event=Events.OPTMIZATION_STEP,
+        event=Events.OPTIMIZATION_STEP,
         subscriber=tracker,
         callback=tracker.update_step,
     )
     optimizer.subscribe(
-        event=Events.OPTMIZATION_END,
+        event=Events.OPTIMIZATION_END,
         subscriber=tracker,
         callback=tracker.update_end,
     )

tests/test_observer.py

@@ -86,19 +86,19 @@ def max(self):
     assert tracker._previous_max is None
     assert tracker._previous_max_params is None
 
-    tracker._update_tracker(Events.OPTMIZATION_STEP, test_instance)
+    tracker._update_tracker(Events.OPTIMIZATION_STEP, test_instance)
     assert tracker._iterations == 1
     assert tracker._previous_max == 1
     assert tracker._previous_max_params == [1, 1]
 
     new_instance = MockInstance(max_target=7, max_params=[7, 7])
-    tracker._update_tracker(Events.OPTMIZATION_STEP, new_instance)
+    tracker._update_tracker(Events.OPTIMIZATION_STEP, new_instance)
     assert tracker._iterations == 2
     assert tracker._previous_max == 7
     assert tracker._previous_max_params == [7, 7]
 
     other_instance = MockInstance(max_target=2, max_params=[2, 2])
-    tracker._update_tracker(Events.OPTMIZATION_STEP, other_instance)
+    tracker._update_tracker(Events.OPTIMIZATION_STEP, other_instance)
     assert tracker._iterations == 3
     assert tracker._previous_max == 7
     assert tracker._previous_max_params == [7, 7]