Dedicate half constraint budget to a suboptimizer

nevergrad/optimization/base.py

@@ -433,19 +433,29 @@ def ask(self) -> p.Parameter:
         current_num_ask = self.num_ask
         # tentatives if a cheap constraint is available
         # TODO: this should be replaced by an optimization algorithm.
-        max_trials = self._constraints_manager.max_trials
+        max_trials = max(
+            1,
+            self._constraints_manager.max_trials // 2
+            if self.budget is None
+            else (self.budget - self.num_ask),
+        )  # half will be used for sub-optimization --- if the optimization method does not need/use a budget.
+        # TODO(oteytaud): actually we could do this even when the budget is known, if we are sure that exceeding the budget is not a problem.
+        # Very simple constraint solver:
+        # - we use a simple algorithm.
+        # - no memory of previous iterations.
+        # - just projection to constraint satisfaction.
+        # We try using the normal tool during half constraint budget, in order to reduce the impact on the normal run.
         for k in range(max_trials):
             is_suggestion = False
-            if self._suggestions:
+            if self._suggestions:  # use suggestions if available
                 is_suggestion = True
                 candidate = self._suggestions.pop()
             else:
                 candidate = self._internal_ask_candidate()
-                # only register actual asked points
             if candidate.satisfies_constraints():
                 break  # good to go!
             if self._penalize_cheap_violations:
-                # TODO using a suboptimizer instead may help remove this
+                # Warning! This might be a tell not asked.
                 self._internal_tell_candidate(candidate, float("Inf"))  # DE requires a tell
             self._num_ask += (
                 1  # this is necessary for some algorithms which need new num to ask another point
@@ -456,6 +466,9 @@ def ask(self) -> p.Parameter:
                     "sending candidate anyway.",
                     errors.FailedConstraintWarning,
                 )
+        if not candidate.satisfies_constraints():
+            # still not solving, let's run sub-optimization
+            candidate = _constraint_solver(candidate, budget=max_trials)
         if not is_suggestion:
             if candidate.uid in self._asked:
                 raise RuntimeError(
@@ -736,3 +749,25 @@ def __eq__(self, other: tp.Any) -> tp.Any:
             if self._config == other._config:
                 return True
         return False
+
+
+def _constraint_solver(parameter: p.Parameter, budget: int) -> p.Parameter:
+    """Runs a suboptimization to solve the parameter constraints"""
+    parameter_without_constraint = parameter.copy()
+    parameter_without_constraint._constraint_checkers.clear()
+    opt = registry["OnePlusOne"](parameter_without_constraint, num_workers=1, budget=budget)
+    opt._constraints_manager.max_trials = 1
+    for _ in range(budget):
+        cand = opt.ask()
+        # Our objective function is minimum for the point the closest to
+        # the original candidate under the constraints.
+        penalty = cand._constraint_penalties()
+        if not penalty > 0:  # constraints are satisfied
+            return cand
+        # TODO: this may not scale well with dimension
+        distance = np.tanh(np.sum(cand.get_standardized_data(reference=parameter) ** 2))
+        # TODO: because of the return whenever constraints are satisfied, the first case never arises
+        loss = distance if penalty <= 0 else penalty + distance + 1.0
+        opt.tell(cand, loss)
+    data = opt.recommend().get_standardized_data(reference=parameter_without_constraint)
+    return parameter.spawn_child().set_standardized_data(data)

nevergrad/optimization/test_optimizerlib.py

@@ -537,7 +537,7 @@ def constraint(i: tp.Any) -> tp.Union[bool, float]:
     optimizer = optlib.OnePlusOne(parametrization, budget=100)
     optimizer.parametrization.random_state.seed(12)
     if penalization:
-        optimizer._constraints_manager.update(max_trials=2, penalty_factor=10)
+        optimizer._constraints_manager.update(max_trials=8, penalty_factor=10)
 
         def constraint(i: tp.Any) -> tp.Union[bool, float]:  # pylint: disable=function-redefined
             return -abs(i[1]["x"][0] - 1)
@@ -645,7 +645,7 @@ def test_bo_ordering() -> None:
         (None, 3, 20, False, 1000, ["MetaModel", "OnePlusOne"]),
     ],
 )
-def test_ngo_split_optimizer(
+def test_ngo_split_optimizer(  # pylint: disable=too-many-arguments
     name: tp.Optional[str],
     dimension: int,
     num_workers: int,

nevergrad/parametrization/core.py

@@ -241,6 +241,17 @@ def __repr__(self) -> str:
 
     # %% Constraint management
 
+    def _constraint_penalties(self) -> float:
+        """Returns the list of constraint penalties penalties
+
+        Returns
+        -------
+        float
+            the sum of the list of penalties for each constraint
+        """
+        val = self.value
+        return sum(utils.float_penalty(func(val)) for func in self._constraint_checkers)
+
     def satisfies_constraints(self) -> bool:
         """Whether the instance satisfies the constraints added through
         the `register_cheap_constraint` method