cma.constraints_handler.ConstrainedFitnessAL

Construct an unconstrained objective function from constraints.

This class constructs an unconstrained "fitness" function (to be minimized) from an objective function and an inequality constraints function (which returns a list of constraint values). An equality constraint h(x) == 0 must be expressed as two inequality constraints like [h(x) - eps, -h(x) - eps] with eps >= 0. Non-positive values <= 0 are considered feasible.

The update method of the class instance needs to be called after each iteration. Depending on the setting of which, update may call get_solution(es) which shall return the solution to be used for the constraints handling update, by default _get_favorite_solution == lambda es: es.ask(1, sigma_fac=0)[0]. The additional evaluation of objective and constraints is avoided by the default which='best', using the best solution in the current iteration.

find_feasible_first optimizes to get a feasible solution first, which only works if no equality constraints are implemented. For this reason the default is False.

Minimal example (verbosity set for doctesting):

>>> import cma
>>> def constraints(x):  # define the constraint
...     return [x[0] + 1, x[1]]  # shall be <= 0
>>> cfun = cma.ConstrainedFitnessAL(cma.ff.sphere, constraints,
...                                 find_feasible_first=True)
>>> es = cma.CMAEvolutionStrategy(3 * [1.1], 0.1,
...                   {'tolstagnation': 0, 'verbose':-9})  # verbosity for doctest only
>>> es = es.optimize(cfun, callback=cfun.update)
>>> x = es.result.xfavorite

The best x return value of cma.fmin2 may not be useful, because the underlying function changes over time. Therefore, we use es.result.xfavorite, which is still not guarantied to be a feasible solution. Alternatively, cfun.best_feas.x contains the best evaluated feasible solution. However, this is not necessarily expected to be a good solution, see below.

>>> assert sum((x - [-1, 0, 0])**2) < 1e-9, x
>>> assert es.countevals < 2200, es.countevals
>>> assert cfun.best_feas.f < 10, str(cfun.best_feas)
>>> # print(es.countevals, cfun.best_feas.__dict__)

To find a final feasible solution (close to es.result.xfavorite) we can use the current CMAEvolutionStrategy instance es:

>>> x = cfun.find_feasible(es)  # uses es.optimize to find (another) feasible solution
>>> assert constraints(x)[0] <= 0, (x, cfun.best_feas.x)
>>> assert cfun.best_feas.f < 1 + 2e-6, str(cfun.best_feas)
>>> assert len(cfun.archives) == 3
>>> assert cma.ConstrainedFitnessAL(cma.ff.sphere, constraints, archives=False).archives == []

Details: The fitness, to be minimized, is changing over time such that the overall minimal value does not indicate the best solution.

The construction is based on the AugmentedLagrangian class. If, as by default, self.finding_feasible is False, the fitness equals f(x) + sum_i (lam_i x g_i + mu_i x g_i / 2) where g_i = max(g_i(x), -lam_i / mu_i) and lam_i and mu_i are generally positive and dynamically adapted coefficients. Only lam_i can change the position of the optimum in the feasible domain (and hence must converge to the right value).

When self.finding_feasible is True, the fitness equals to sum_i (g_i > 0) x g_i^2 and omits f + sum_i lam_i g_i altogether. Whenever a feasible solution is found, the finding_feasible flag is reset to False.

find_feasible(es) sets finding_feasible = True and uses es.optimize to optimize self.__call__. This works well with CMAEvolutionStrategy but may easily fail with solvers that do not consistently pass over the optimum in search space but approach the optimum from one side only. This is not advisable if the feasible domain has zero volume, e.g. when g models an equality like g = lambda x: [h(x), -h(x)].

An equality constraint, h(x) = 0, cannot be handled like h**2 <= 0, because the Augmented Lagrangian requires the derivative at h == 0 to be non-zero. Using abs(h) <= 0 leads to divergence of coefficient mu and the condition number. The best way is apparently using the two inequality constraints [h <= 0, -h <= 0], which seems to work perfectly well. The underlying AugmentedLagrangian class also accepts equality constraints.