cma

package documentation

Package cma implements the CMA-ES (Covariance Matrix Adaptation Evolution Strategy).

CMA-ES is a stochastic optimizer for robust non-linear non-convex derivative- and function-value-free numerical optimization.

This implementation can be used with Python versions >= 2.7, namely, it was tested with 2.7, 3.5, 3.6, 3.7, 3.8.

CMA-ES searches for a minimizer (a solution x in Rⁿ) of an objective function f (cost function), such that f(x) is minimal. Regarding f, only a passably reliable ranking of the candidate solutions in each iteration is necessary. Neither the function values itself, nor the gradient of f need to be available or do matter (like in the downhill simplex Nelder-Mead algorithm). Some termination criteria however depend on actual f-values.

The cma module provides two independent implementations of the CMA-ES algorithm in the classes cma.CMAEvolutionStrategy and cma.purecma.CMAES.

In each implementation two interfaces are provided:

functions fmin2 and purecma.fmin:

run a complete minimization of the passed objective function with CMA-ES. fmin also provides optional restarts and noise handling.
class CMAEvolutionStrategy and purecma.CMAES:

allow for minimization such that the control of the iteration loop remains with the user.

The cma package root provides shortcuts to these and other classes and functions.

Used external packages are numpy (only purecma does not depend on numpy) and matplotlib.pyplot (for plot etc., optional but highly recommended).

Install

To use the module, the folder cma only needs to be visible in the python path, e.g. in the current working directory.

To install the module from pipy, type:

pip install cma

from the command line.

To install the module from a cma folder:

pip install -e cma

To upgrade the currently installed version use additionally the -U option.

Testing

From the system shell:

python -m cma.test -h
python -m cma.test
python -c "import cma.test; cma.test.main()"  # the same

or from any (i)python shell:

import cma.test
cma.test.main()

should run without complaints in about between 20 and 100 seconds.

Example

From a python shell:

import cma
help(cma)  # "this" help message, use cma? in ipython
help(cma.fmin)
help(cma.CMAEvolutionStrategy)
help(cma.CMAOptions)
cma.CMAOptions('tol')  # display 'tolerance' termination options
cma.CMAOptions('verb') # display verbosity options
res = cma.fmin(cma.ff.tablet, 15 * [1], 1)
es = cma.CMAEvolutionStrategy(15 * [1], 1).optimize(cma.ff.tablet)
help(es.result)
res[0], es.result[0]  # best evaluated solution
res[5], es.result[5]  # mean solution, presumably better with noise

Authors
Nikolaus Hansen, 2008-
Petr Baudis, 2014
Youhei Akimoto, 2017-
See Also
`fmin` (), `CMAOptions`, `CMAEvolutionStrategy`
Unknown Field: license
BSD 3-Clause, see LICENSE file.

Module	`bbobbenchmarks`	BBOB noiseless testbed.
Module	`constraints_handler`	A collection of boundary and (in future) constraints handling classes.
Module	`evolution_strategy`	CMA-ES (evolution strategy), the main sub-module of `cma` providing in particular `CMAOptions`, `CMAEvolutionStrategy`, and `fmin2`
Module	`fitness_functions`	versatile container for test objective functions.
Module	`fitness_models`	Fitness surrogate model classes and handler for incremental evaluations.
Module	`fitness_transformations`	Wrapper for objective functions like noise, rotation, gluing args
Module	`interfaces`	Very few interface defining base class definitions
Module	`logger`	logger class mainly to be used with `CMAEvolutionStrategy`
Module	`optimization_tools`	Utility classes and functionalities loosely related to optimization
Module	`purecma`	A minimalistic implemention of CMA-ES without using `numpy`.
Module	`recombination_weights`	`RecombinationWeights` is a list of recombination weights for the CMA-ES.
Module	`restricted_gaussian_sampler`	VD-CMA and VkD-CMA
Module	`s`	versatile shortcuts for quick typing in an (i)python shell or even `from cma.s import *` in interactive sessions.
Module	`sampler`	Collection of classes that sample from parametrized distributions and provide an update mechanism of the distribution parameters.
Module	`sigma_adaptation`	step-size adaptation classes, currently tightly linked to CMA, because `hsig` is computed in the base class
Module	`test`	test module of `cma` package.
Module	`transformations`	Search space transformation and encoding/decoding classes
Package	`utilities`	various unspecific utilities
Module	`wrapper`	Interface wrappers for the `cma` module.

From __init__.py:

Variable	`___author__`	Undocumented
Variable	`__license__`	Undocumented
Variable	`__version__`	Undocumented

___author__: str = ¶

Undocumented

__license__: str = ¶

Undocumented

__version__: str = ¶

Undocumented