comocma.como.Sofomore

Calling Sequences

• moes = Sofomore(list_of_solvers_instances, reference_point, opts)
• moes = Sofomore(list_of_solvers_instances, reference_point)
• moes = Sofomore(list_of_solvers_instances, reference_point).optimize(objective_fcts)

Arguments

list_of_solvers_instances

list of instances of single-objective solvers. It's generally created via a factory function. Let's take the example of a factory function that returns cma-es instances, called get_cmas. Then: list_of_solvers_instances = get_cmas(11 * [x0], sigma0) creates a list of 11 cma-es instances of initial mean x0 and initial step-size sigma0. A single-objective solver instance must have the following attributes and methods:

• incumbent: an attribute that gives an estimate of the single-objective solver.
• objective_values: an attribute that stores the objective values of the incumbent.
• stop: a method returning a dictionary representing the termination status.
• ask: generates new candidate solutions.
• tell: passes the objective values and updates the states of the single-objective solvers.

opts

opts, a dictionary with optional settings related to the Sofomore framework. It mainly contains the following keys:

• 'archive': default value is True. If its value is True, tracks the non-dominated points that dominate the reference point, among the points evaluated so far during the optimization. The archive will not interfere with the optimization process.
• 'indicator_front': default value is None. Used via self.indicator_front = IndicatorFront(self.opts['indicator_front']) within the __init__ method of Sofomore. See the class IndicatorFront for more details.
• 'restart': used to define in __init__ the attribute restart via self.restart = self.opts['restart'].
• 'update_order': default value is a function that takes a natural integer as input and returns a random number between 0 and 1. It is used as a key value in: sorted(..., key = ...), and guides the order in which the kernels will be updated during the optimization.

reference_point

reference point of the multiobjective optimization. Its default value is None but should be set by the user beforehand to guarantee an optimal p-distribution convergence of the Hypervolume indicator of p points towards the Pareto set/front. It can be changed dynamically by the user if needed.

Main interface / usage

The interface is inherited from the generic OOOptimizer class, which is the same interface used by the pycma module. An object instance is generated as following:

>>> import cma, comocma
>>> import numpy as np
>>> reference_point = [11, 11]
>>> num_kernels = 11 # the number of points we seek to have on the Pareto front
>>> dimension = 5 # the dimension of the search space
>>> x0 = dimension * [0] # an initial mean for cma
>>> sigma0 = 0.2 # initial step-size for cma
>>> list_of_solvers_instances = comocma.get_cmas(num_kernels * [x0], sigma0, {'verbose':-9})
>>> # `comocma.get_cmas` is a factory function that returns `num_kernels` cma-es instances
>>> moes = comocma.Sofomore(list_of_solvers_instances,
...                      reference_point) #instantiation of our MO optimizer

The least verbose interface is via the optimize method:

>>> fitness = comocma.FitFun(cma.ff.sphere, lambda x: cma.ff.sphere(x-1)) # a callable bi-objective function
>>> moes.optimize(fitness, iterations=23) # doctest:+ELLIPSIS
Iterat #Fevals   Hypervolume   axis ratios   sigmas   min&max stds***

>>> list_of_solvers_instances = comocma.get_cmas(num_kernels * [x0], sigma0, {'verbose':-9})
>>> reference_point = [11, 11, 11]
>>> moes = comocma.Sofomore(list_of_solvers_instances,
...                      reference_point) #instantiation of our MO optimizer
>>> fitness = comocma.FitFun(cma.ff.sphere, lambda x: cma.ff.sphere(x-1),
...                       lambda x: cma.ff.sphere(x+1)) # a callable 3-objective function
>>> moes.optimize(fitness, iterations=4) # doctest:+ELLIPSIS
Iterat #Fevals   Hypervolume   axis ratios   sigmas   min&max stds***

More verbosely, the optimization of the callable multiobjective function fitness is done via the ask-and-tell interface:

>>> list_of_solvers_instances = comocma.get_cmas(num_kernels * [x0], sigma0, {'verbose':-9})
>>> moes = comocma.Sofomore(list_of_solvers_instances, reference_point)
>>> while not moes.stop() and moes.countiter < 30:
...     solutions = moes.ask() # `ask` delivers new candidate solutions
...     objective_values = [fitness(x) for x in solutions]
...     moes.tell(solutions, objective_values)
...  # `tell` updates the MO instance by passing the respective function values.
...     # moes.logger.add()
...     moes.disp() # doctest:+ELLIPSIS
***

One iteration of the optimize interface is equivalent to one step in the loop of the ask-and-tell interface. But for the latter, the prototyper has more controls to analyse and guide the optimization, due to the access of the instance between the ask and the tell calls.

Attributes and Properties

• archive: list of non-dominated points among all points evaluated so far, which dominate the reference point.
• countevals: the number of function evaluations.
• countiter: the number of iterations.
• dimension: is the dimension of the search space.
• indicator_front: the indicator used as a changing fitness inside an iteration of Sofomore. By default it is the UHVI of all the objective values of the kernels' incumbents, except the kernel being optimized. See the class IndicatorFront for more details.
• isarchive: a boolean accessible via self.opts['archive']. If True, we keep track of the archive, otherwise we don't.
• kernels: initialized with list_of_solvers_instances, and is the list of single-objective solvers.
• key_sort_indices: default value is self.opts['update_order']. It is a function used as a key to sort some kernels' indices, in order to select the first indices during the call of the ask method.
• logger: an attribute that accounts for the way we log the Sofomore data during an optimization. self.logger is an instance of the SofomoreDataLogger class.
• NDA: it is the non-dominated archiving method used within Sofomore. By default the class BiobjectiveNondominatedSortedList is used in two objectives and the class (non tested yet) NonDominatedList is used for three or more objectives.
• opts: passed options.
• offspring: list of tuples of the index of a kernel with its corresponding candidate solutions, that we generally get with the cma's ask method.
• pareto_front_cut: list of non-dominated points among the incumbents of self.kernels, which dominate the reference point.
• pareto_set_cut: preimage of pareto_front_cut.
• reference_point: the current reference point.
• restart: accessible via self.opts['restart']. If not None, a callback function that adds kernels after a kernel of the running Sofomore instance stops. Its default value is None, meaning that we do not do any restart.
• _active_indices: the indices of the kernels that have not stopped yet.
• _last_stopped_kernel_id: the index of the last stopped kernel.
• _told_indices: the kernels' indices for which we will evaluate the objective values of their incumbents, before the next call of the tell method. And before the first call of tell, they are the indices of all the initial kernels (i.e. range(len(self))). And before another call of tell, they are the indices of the kernels from which we have sampled new candidate solutions during the penultimate ask method. Note that we should call the ask method before any call of the tell method.