cma 4.4.2__tar.gz → 4.4.4__tar.gz

{cma-4.4.2 → cma-4.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cma
-Version: 4.4.2
+Version: 4.4.4
 Summary: CMA-ES, Covariance Matrix Adaptation Evolution Strategy for non-linear numerical optimization in Python
 Author: Nikolaus Hansen, Youhei Akimoto, Petr Baudis
 Maintainer-email: Nikolaus Hansen <authors_firstname.lastname@inria.fr>
@@ -29,31 +29,42 @@ Provides-Extra: plotting
 Requires-Dist: matplotlib; extra == "plotting"
 Provides-Extra: constrained-solution-tracking
 Requires-Dist: moarchiving; extra == "constrained-solution-tracking"
+Provides-Extra: statistical-tests
+Requires-Dist: scipy; extra == "statistical-tests"
 Dynamic: license-file
 
 CMA-ES Covariance Matrix Adaptation Evolution Strategy
 ======================================================
 
-A stochastic numerical optimization algorithm for difficult (non-convex,
-ill-conditioned, multi-modal, rugged, noisy) optimization problems in
-continuous or mixed-integer search spaces, implemented in Python.
+The CMA-ES is a randomized derivative-free numerical optimization algorithm for
+difficult (non-convex, ill-conditioned, multi-modal, rugged, noisy) optimization
+problems in continuous or mixed-integer search spaces, implemented in Python.
 
-Typical domain of application are unconstrained or bound-constrained
-objective functions with:
+The typical domain of application are objective functions with:
 
-* search space dimension between, say, five and a few hundred,
-* no gradients available,
-* at least, say, 100 times dimension function evaluations needed
-  to get satisfactory solutions,
-* non-separable, ill-conditioned, or rugged/multi-modal landscapes.
+* search space dimension between five and a few hundred,
+* dependent decision variables (non-separable)
+* gradients not being available or useful,
+* at least, say, 100 times dimension function evaluations possible and
+  needed to get a satisfactory solution,
+* ill-conditioned or rugged or multi-modal landscapes.
 
-Nonlinear constraints handling is available too.
-The CMA-ES is quite reliable, however for small budgets (fewer function
-evaluations than, say, 100 times dimension) or in very small dimensions
-faster methods are available.
+The handling of
 
-The ``pycma`` module provides two independent implementations of the 
-CMA-ES algorithm in the classes `cma.CMAEvolutionStrategy`_ and 
+* bound constraints via the ``'bounds' = [lower, upper]`` option or the
+  `cma.BoundDomainTransform` wrapper
+* linear and nonlinear constraints via the ``constraints`` argument to `fmin2`
+  or `fmin_con2`
+* noise via ``noise_handler=True`` as argument to `fmin2`
+* integer variables for mixed-integer problems via the
+  ``'integer_variables'=index_list`` option
+
+is available too. The CMA-ES is quite reliable, however for small budgets
+(fewer function evaluations than 100 times dimension) or in very small
+dimensions faster methods are available.
+
+The ``pycma`` module provides two independent implementations of the CMA-ES
+algorithm in the classes `cma.CMAEvolutionStrategy`_ and a basic implementation
 `cma.purecma.CMAES`_.
 
 Installation

{cma-4.4.2 → cma-4.4.4}/README.rst

@@ -1,26 +1,35 @@
 CMA-ES Covariance Matrix Adaptation Evolution Strategy
 ======================================================
 
-A stochastic numerical optimization algorithm for difficult (non-convex,
-ill-conditioned, multi-modal, rugged, noisy) optimization problems in
-continuous or mixed-integer search spaces, implemented in Python.
-
-Typical domain of application are unconstrained or bound-constrained
-objective functions with:
-
-* search space dimension between, say, five and a few hundred,
-* no gradients available,
-* at least, say, 100 times dimension function evaluations needed
-  to get satisfactory solutions,
-* non-separable, ill-conditioned, or rugged/multi-modal landscapes.
-
-Nonlinear constraints handling is available too.
-The CMA-ES is quite reliable, however for small budgets (fewer function
-evaluations than, say, 100 times dimension) or in very small dimensions
-faster methods are available.
-
-The ``pycma`` module provides two independent implementations of the 
-CMA-ES algorithm in the classes `cma.CMAEvolutionStrategy`_ and 
+The CMA-ES is a randomized derivative-free numerical optimization algorithm for
+difficult (non-convex, ill-conditioned, multi-modal, rugged, noisy) optimization
+problems in continuous or mixed-integer search spaces, implemented in Python.
+
+The typical domain of application are objective functions with:
+
+* search space dimension between five and a few hundred,
+* dependent decision variables (non-separable)
+* gradients not being available or useful,
+* at least, say, 100 times dimension function evaluations possible and
+  needed to get a satisfactory solution,
+* ill-conditioned or rugged or multi-modal landscapes.
+
+The handling of
+
+* bound constraints via the ``'bounds' = [lower, upper]`` option or the
+  `cma.BoundDomainTransform` wrapper
+* linear and nonlinear constraints via the ``constraints`` argument to `fmin2`
+  or `fmin_con2`
+* noise via ``noise_handler=True`` as argument to `fmin2`
+* integer variables for mixed-integer problems via the
+  ``'integer_variables'=index_list`` option
+
+is available too. The CMA-ES is quite reliable, however for small budgets
+(fewer function evaluations than 100 times dimension) or in very small
+dimensions faster methods are available.
+
+The ``pycma`` module provides two independent implementations of the CMA-ES
+algorithm in the classes `cma.CMAEvolutionStrategy`_ and a basic implementation
 `cma.purecma.CMAES`_.
 
 Installation

{cma-4.4.2 → cma-4.4.4}/pyproject.toml

@@ -9,7 +9,7 @@
 requires = [
     "setuptools >=79",
     # "setuptools-scm",   # if we want to use git versions for versioning
-    "wheel",  # setuptools doesn't need wheel anymore, see https://pypi.org/project/wheel/
+    # "wheel",  # setuptools doesn't need wheel anymore, see https://pypi.org/project/wheel/
 ]
 build-backend = "setuptools.build_meta"
 
@@ -60,16 +60,18 @@ classifiers = [
 # packages = ["cma", "cma.utilities"]  # fails when they are in an src/ folder
 include-package-data = false  # true is default, false doesn't change anything
 
-[tool.setuptools.packages.find]  # for where=. works only in a clean folder
-# where = ["src"]  # this doesn't work, it always takes the root too?
-include = ["cma*"]
-exclude = ["notebooks*"]
+# [tool.setuptools.packages.find]  # for where=. works only in a clean folder
+# without any directives: finds src folder implying a standard (nonflat) layout
+# # where = ["src"]  # this doesn't work, it always takes the root too?
+# include = ["cma*"]  # cma/* ?
+# exclude = ["notebooks*"]  # , "cma_*" ?
 
 # namespaces = false
 
 [project.optional-dependencies]
 plotting = ["matplotlib"]
 constrained-solution-tracking = ["moarchiving"]
+statistical-tests = ["scipy"]
 
 [project.urls]
 Homepage = "https://github.com/CMA-ES/pycma"

{cma-4.4.2 → cma-4.4.4/src}/cma/__init__.py

@@ -103,14 +103,15 @@ del _ab, _di, _pr
 
 ___author__ = "Nikolaus Hansen and Petr Baudis and Youhei Akimoto"
 __license__ = "BSD 3-clause"
-__version__ = "4.4.2"
+__version__ = "4.4.4"
+'''version 4.4.4'''  # allows the apidocs to "pick up" the version number
 
 
 import collections as _collections
 import warnings as _warnings
 
 # __package__ = 'cma'
-from . import purecma
+from .more_algorithms import purecma
 try:
     import numpy as _np
 except ImportError:

{cma-4.4.2 → cma-4.4.4/src}/cma/evolution_strategy.py

@@ -202,6 +202,7 @@ from . import optimization_tools as ot
 from . import sampler
 from .utilities import utils
 from .options_parameters import CMAOptions, cma_default_options
+from . import warnings_and_exceptions as _cma_warnings
 from . import constraints_handler as _constraints_handler
 from cma import fitness_models as _fitness_models
 from .boundary_handler import BoundNone, BoundPenalty, BoundTransform
@@ -1045,6 +1046,8 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
         `options` is for consistency with `fmin2` options and is only
         in effect if ``inopts is None``.
         """
+        _cma_warnings.filterwarning('once',
+                                    category=_cma_warnings.NeverTestedWarning)
         if options and inopts is None:
             inopts = options
         del options
@@ -1374,6 +1377,10 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
         self.noiseS = 0  # noise "signal"
         self.hsiglist = []
 
+        try:  # prevent that late initialization overwrites values during first update call
+            self.adapt_sigma.initialize(self)
+        except Exception:
+            pass
         self.sent_solutions = get_CMASolutionDict(archive_sent_solutions)()
         '''archive solutions close to the end of `ask`, this archive is
            passed to ``gp.geno`` to bypass calling the inverse geno-pheno
@@ -1400,10 +1407,10 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                                     expensive_modulo=opts['verb_log_expensive']).register(self)
 
         self._stopdict = _CMAStopDict()
-        "    attribute for stopping criteria in function stop"
+        '''attribute for stopping criteria in function stop'''
         self._stoptolxstagnation = _StopTolXStagnation(self.mean)
         self.callbackstop = ()
-        "    return values of callbacks, used like ``if any(callbackstop)``"
+        '''return values of callbacks, used like ``if any(callbackstop)``'''
         self.fit = _BlancClass()
         self.fit.fit = None  # objective function values sorted
         self.fit.bndpen = None  # boundary penalty values
@@ -1679,6 +1686,10 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                                     "sampler attributes `B` and `D` are not present",
                                     "ask", "CMAEvolutionStrategy",
                                     self.countiter, maxwarns=1)
+            warnings.warn("the `gradf` argument to `ask` has not been thoroughly tested,"
+                "\n  consider to use ``es.inject(es.mean - delta * gradf(es.mean)``"
+                " with a large value for delta.",
+                category=_cma_warnings.NeverTestedWarning)
             try:
                 # see Hansen (2011), Injecting external solutions into CMA-ES
                 if not self.gp.islinear:
@@ -1687,12 +1698,18 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                     coordinate-wise transformation (option ``transformation``)
                     has never been tested.""")
                     # TODO: check this out
+                def _rm_fixed(y):
+                    """return y unchanged or a copy of y without fixed variables"""
+                    if not self.opts['fixed_variables']:
+                        return y
+                    return np.asarray([y[i] for i in range(len(y))
+                                       if i not in self.opts['fixed_variables']])
                 def grad_numerical_of_coordinate_map(x, map, epsilon=None):
                     """map is a coordinate-wise independent map, return
                     the estimated diagonal of the Jacobian.
                     """
                     eps = 1e-8 * (1 + abs(x)) if epsilon is None else epsilon
-                    return (map(x + eps) - map(x - eps)) / (2 * eps)
+                    return _rm_fixed(map(x + eps) - map(x - eps)) / (2 * eps)
                 def grad_numerical_sym(x, func, epsilon=None):
                     """return symmetric numerical gradient of func : R^n -> R.
                     """
@@ -1722,7 +1739,7 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                     xmean = self.mean
                 xpheno = self.gp.pheno(xmean, copy=True,
                                        into_bounds=self.boundary_handler.repair)
-                grad_at_mean = gradf(xpheno, *args)
+                grad_at_mean = _rm_fixed(gradf(xpheno, *args))
                 # lift gradient into geno-space
                 if not self.gp.isidentity or (self.boundary_handler is not None
                         and self.boundary_handler.has_bounds()):
@@ -1735,8 +1752,7 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                         def fpenalty(x):
                             return self.boundary_handler.__call__(
                                 x, _SolutionDict({tuple(x): {'geno': x}}), self.gp)
-                        gradpen = grad_numerical_sym(
-                            xmean, fpenalty)
+                        gradpen = _rm_fixed(grad_numerical_sym(xmean, fpenalty))
                     elif self.boundary_handler is None or \
                             isinstance(self.boundary_handler,
                                         BoundNone):
@@ -1751,11 +1767,16 @@ class CMAEvolutionStrategy(interfaces.OOOptimizer):
                     gradgp = grad_numerical_of_coordinate_map(xmean, _gp_for_num_grad)
                     grad_at_mean = grad_at_mean * gradgp + gradpen
 
-                # TODO: frozen variables brake the code (e.g. at grad of map)
-                if len(grad_at_mean) != self.N or self.opts['fixed_variables']:
-                    NotImplementedError("""
-                    gradient with fixed variables is not (yet) implemented,
-                    implement a simple transformation of the objective instead""")
+                # DONE: frozen variables break the code (e.g. at grad of map)
+                if self.opts['fixed_variables']:
+                    warnings.warn("gradient with fixed variables was never tested, consider"
+                        "\n  to implement a simple transformation of the objective instead"
+                        "\n  see `cma.fitness_transformations.FixVariables`",
+                        category=_cma_warnings.NeverTestedWarning)
+                if len(grad_at_mean) != self.N:
+                    warnings.warn("gradient dimension={0}!={1}=genotype dimension."
+                                  "This will lead to an exception soon."
+                                  .format(len(grad_at_mean), self.N))
                 v = self.sm.D * np.dot(self.sm.B.T, self.sigma_vec * grad_at_mean)
                 # newton_direction = sv * B * D * D * B^T * sv * gradient = sv * B * D * v
                 # v = D^-1 * B^T * sv^-1 * newton_direction = D * B^T * sv * gradient
@@ -4680,8 +4701,10 @@ def fmin2(objective_function, x0, sigma0,
 
     We can use the gradient like
 
-    >>> import cma
-    >>> x, es = cma.fmin2(cma.ff.rosen, np.zeros(10), 0.1,
+    >>> import cma, warnings
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('ignore', category=cma.warnings_and_exceptions.NeverTestedWarning)
+    ...     x, es = cma.fmin2(cma.ff.rosen, np.zeros(10), 0.1,
     ...             options = {'ftarget':1e-8,},
     ...             gradf=cma.ff.grad_rosen,
     ...         )  #doctest: +ELLIPSIS
@@ -4830,8 +4853,10 @@ def fmin(objective_function, x0, sigma0, *posargs, **kwargs):
 
     We can use the gradient like
 
-    >>> import cma
-    >>> res = cma.fmin(cma.ff.rosen, np.zeros(10), 0.1,
+    >>> import cma, warnings
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('ignore', category=cma.warnings_and_exceptions.NeverTestedWarning)
+    ...     res = cma.fmin(cma.ff.rosen, np.zeros(10), 0.1,
     ...             options = {'ftarget':1e-8,},
     ...             gradf=cma.ff.grad_rosen,
     ...         )  #doctest: +ELLIPSIS