Merge remote-tracking branch 'origin/master' into parameter-types

bayes_opt/bayesian_optimization.py

@@ -220,7 +220,7 @@ def suggest(self, utility_function):
         suggestion = acq_max(ac=utility_function.utility,
                              gp=self._gp,
                              constraint=self.constraint,
-                             y_max=self._space.target.max(),
+                             y_max=self._space._target_max(),
                              bounds=self._space.float_bounds,
                              random_state=self._random_state)
         return self._space.array_to_params(suggestion)

bayes_opt/target_space.py

@@ -2,7 +2,7 @@
 from .util import ensure_rng, NotUniqueError
 from .parameter import FloatParameter, IntParameter, is_numeric, CategoricalParameter
 from .constraint import ConstraintModel
-
+from .util import Colours
 
 def _hashable(x):
     """ ensure that an point is hashable by a python dict """
@@ -25,11 +25,8 @@ class TargetSpace(object):
     >>> assert self.max_point()['max_val'] == y
     """
 
-    def __init__(self,
-                 target_func,
-                 pbounds,
-                 constraint=None,
-                 random_state=None):
+    def __init__(self, target_func, pbounds, constraint=None, random_state=None,
+                 allow_duplicate_points=False):
         """
         Parameters
         ----------
@@ -70,6 +67,8 @@ def __init__(self,
         # keep track of unique points we have seen so far
         self._cache = {}
 
+        self._constraint = constraint
+
         if constraint is not None:
             self._constraint = ConstraintModel(constraint.fun,
                                                constraint.lb,
@@ -260,7 +259,13 @@ def register(self, params, target, constraint_value=None):
             x = self.params_to_array(params)
 
         if x in self:
-            raise NotUniqueError('Data point {} is not unique'.format(x))
+            if self._allow_duplicate_points:
+                self.n_duplicate_points = self.n_duplicate_points + 1
+                print(f'{Colours.RED}Data point {x} is not unique. {self.n_duplicate_points} duplicates registered.'
+                              f' Continuing ...{Colours.END}')
+            else:
+                raise NotUniqueError(f'Data point {x} is not unique. You can set "allow_duplicate_points=True" to '
+                                     f'avoid this error')
 
         self._params = np.concatenate([self._params, x.reshape(1, -1)])
         self._target = np.concatenate([self._target, np.atleast_1d(target)])
@@ -270,9 +275,8 @@ def register(self, params, target, constraint_value=None):
             self._cache[_hashable(x.ravel())] = target
         else:
             if constraint_value is None:
-                msg = (
-                    "When registering a point to a constrained TargetSpace" +
-                    " a constraint value needs to be present.")
+                msg = ("When registering a point to a constrained TargetSpace" +
+                       " a constraint value needs to be present.")
                 raise ValueError(msg)
             # Insert data into unique dictionary
             self._cache[_hashable(x.ravel())] = (target, constraint_value)
@@ -305,7 +309,6 @@ def probe(self, params):
         else:
             assert type(params) == dict
             x = self.params_to_array(params)
-
         try:
             return self._cache[_hashable(x)]
         except KeyError:
@@ -363,33 +366,22 @@ def max(self):
 
         If there is a constraint present, the maximum value that fulfills the
         constraint is returned."""
-        if self._constraint is None:
-            try:
-                res = {
-                    'target':
-                    self.target.max(),
-                    'params':
-                    self.array_to_params(self.params[self.target.argmax()])
-                }
-            except ValueError:
-                res = {}
-            return res
-        else:
-            allowed = self._constraint.allowed(self._constraint_values)
-            if allowed.any():
-                # Getting of all points that fulfill the constraints, find the
-                # one with the maximum value for the target function.
-                sorted = np.argsort(self.target)
-                idx = sorted[allowed[sorted]][-1]
-                # there must be a better way to do this, right?
-                res = {
-                    'target': self.target[idx],
-                    'params': dict(zip(self.keys, self.params[idx])),
-                    'constraint': self._constraint_values[idx]
-                }
-            else:
-                res = {'target': None, 'params': None, 'constraint': None}
-            return res
+        target_max = self._target_max()
+
+        if target_max is None:
+            return None
+
+        target_max_idx = np.where(self.target == target_max)[0][0]
+
+        res = {
+                'target': target_max,
+                'params': self.array_to_params(self.params[self.target.argmax()])
+        }
+
+        if self._constraint is not None:
+            res['constraint'] = self._constraint_values[target_max_idx]
+
+        return res
 
     def res(self):
         """Get all target values and constraint fulfillment for all parameters.
@@ -402,15 +394,22 @@ def res(self):
                 "params": param
             } for target, param in zip(self.target, params)]
         else:
-            params = params = [self.array_to_params(p) for p in self.params]
-            return [{
-                "target": target,
-                "constraint": constraint_value,
-                "params": param,
-                "allowed": allowed
-            } for target, constraint_value, param, allowed in zip(
-                self.target, self._constraint_values, params,
-                self._constraint.allowed(self._constraint_values))]
+            params = [self.array_to_params(p) for p in self.params]
+
+            return [
+                {
+                    "target": target,
+                    "constraint": constraint_value,
+                    "params": param,
+                    "allowed": allowed
+                }
+                for target, constraint_value, param, allowed in zip(
+                    self.target,
+                    self._constraint_values,
+                    params,
+                    self._constraint.allowed(self._constraint_values)
+                )
+            ]
 
     def set_bounds(self, new_bounds):
         """