J-jj dZddlmZmZmZddlZddlmZddlZddl Z ddl Z ddl Z ddl Z ddl Zddl mZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlmZddlmZddl m!Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z-ddl+m.Z.ddl+m/Z0ddl1m2Z2m3Z4ddl5ddlm6Z7dZ8 dZ9 dZ: dZ; dZ< ejzZ>[[[dZ?dZ@ejdk\ZB dZC ejdk\ZD dZE d ZF Gd!d"eGZHd#ZId$ZJd@d%ZKGd&d'e0ZLGd(d)eMZNdZOdZPdZQdZRdZSGd*d+ejd+gd,ZUGd-d.eVZWGd/d0eXZYGd1d2ejZ[Gd3d4eVZ\Gd5d6eMZ]dAd7Z^dddd8dejdfd9Z` dBd:ZagZbd;Zcd<Zdd=Zeededddfd>Zfeddddfd?Zgy)CzCMA-ES (evolution strategy), the main sub-module of `cma` implementing in particular `CMAEvolutionStrategy`, `fmin2` and further ``fmin_*`` functions. )absolute_importdivisionprint_functionN)range)infarray) interfaces)options_parameters)transformations)optimization_tools)sampler)utils) CMAOptionscma_default_options)warnings_and_exceptions)constraints_handler)fitness_models) BoundNone BoundPenaltyBoundTransform)IntegerCentering) CMADataLogger) BlancClass)rglen) SolutionDict)Mhifloat)*)restricted_gaussian_samplerg@FTznot anymore in effect)geAceZdZdZy)InjectionWarningz5Injected solutions are not passed to tell as expectedN__name__ __module__ __qualname____doc__d/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/evolution_strategy.pyr%r%s?r,r%c*|gSt|r|gS|S)zA `callable` is wrapped and `None` defaults to the empty list. All other values, in particular `False`, remain unmodified on return. )callable)cs r-_callable_to_listr1 s!  y !s Hr,c|r|dSdS)z7a callable that does nothing and return args[0] in caserNr+)argskwargss r-_passr5s47$$r,c|rtStS)z5return a functional or a template "empty" class. )_CMASolutionDict_functional_CMASolutionDict_empty) functionals r-get_CMASolutionDictr:s+5 &P:PPr,c*eZdZfdZ ddZxZS)r7c:tt| |i|d|_yNr)superr7__init__last_solution_index)selfr3r4 __class__s r-r?z$_CMASolutionDict_functional.__init__s  )494J6J#$ r,c|-||jkDr|dzdkr|jd|dz n5|3|jdr"|d}|dzdkr|jd|dz |xjdz c_||jd|}|||jkDrd|_||_n|jdz}||}nd|i}|||d <||d<|||d <|||d <|||<|S) aTinsert an entry with key ``key`` and value ``value if value is not None else {'geno':key}`` and ``self[key]['kwarg'] = kwarg if kwarg is not None`` for the further kwargs. TODO: this looks overdesigned. Only the keyword `iteration` is currently used and not even necessary anymore because `SolutionDict` is now ordered. Just using `SolutionDict` would be good enough with insertions done using a `dict` as value if desired, or a single `info` argument could be implemented in `SolutionDict` for any additional information. ri, iterationr?phenogenofitnesscma_norm)last_iterationtruncategetr@)rAkeyrIrFrJvaluerKentrys r-insertz"_CMASolutionDict_functional.insert's%  Y1D1D%D)VX.\]I] MM#y1} -  599[#9k*IB!# c9q=1   A%   +y9I  4...+,("+D ++c1I  EcNE   E&M&k  &E)    (E* S  r,)NNNNN)r'r(r)r?rR __classcell__rBs@r-r7r7s%>B%)*r,r7c4eZdZdZdZdZdZdZdZdZ y) r8z(a hack to get most code examples runningcyNr+rAr3r4s r-rRz_CMASolutionDict_empty.insertU r,cyrWr+rArOs r-rNz_CMASolutionDict_empty.getWsr,cyrWr+rXs r-rMz_CMASolutionDict_empty.truncateYrYr,cyrWr+rXs r- truncate_toz"_CMASolutionDict_empty.truncate_to[rYr,ciSrWr+r[s r- __getitem__z"_CMASolutionDict_empty.__getitem__]s r,cyrWr+)rArOrPs r- __setitem__z"_CMASolutionDict_empty.__setitem___rYr,N) r'r(r)r*rRrNrMr^r`rbr+r,r-r8r8Ss#2    r,r8ceZdZdZy)CMAEvolutionStrategyResultaA results tuple from `CMAEvolutionStrategy` property ``result``. This tuple contains in the given position and as attribute - 0 ``xbest`` best solution evaluated - 1 ``fbest`` objective function value of best solution - 2 ``evals_best`` evaluation count when ``xbest`` was evaluated - 3 ``evaluations`` evaluations overall done - 4 ``iterations`` - 5 ``xfavorite`` distribution mean in "phenotype" space, to be considered as current best estimate of the optimum - 6 ``stds`` effective standard deviations, can be used to compute a lower bound on the expected coordinate-wise distance to the true optimum, which is (very) approximately stds[i] * dimension**0.5 / min(mueff, dimension) / 1.5 / 5 ~ std_i * dimension**0.5 / min(popsize / 2, dimension) / 5, where dimension = CMAEvolutionStrategy.N and mueff = CMAEvolutionStrategy.sp.weights.mueff ~ 0.3 * popsize. - 7 ``stop`` termination conditions in a dictionary The penalized best solution of the last completed iteration can be accessed via attribute ``pop_sorted[0]`` of `CMAEvolutionStrategy` and the respective objective function value via ``fit.fit[0]``. Details: - This class is of purely declarative nature and for providing this docstring. It does not provide any further functionality. - ``list(.fit.idx).index(0)`` is the index of the first sampled solution of the last completed iteration in ``pop_sorted``. Nr&r+r,r-rdrdnsr,rd)xbestfbest evals_best evaluations iterations xfavoritestdsstopcZeZdZdZdZedZedZdZdZ dZ dZ d Z d Z y ) CMAEvolutionStrategyResult2aDA results class. This class is of rather declarative nature allowing to access the result in its attributes after running an optimization. Additionally, the class provides a `names` and an `asdict` property. >>> import cma >>> es = cma.CMA(2 * [1], .1, {'verbose': -9}).optimize(cma.ff.sphere, 4, iterations=5) >>> isinstance(es.result, cma.evolution_strategy.CMAEvolutionStrategyResult2) True The easiest ways to examine the results visually is by ``list(es.result)`` or like >>> es.result.asdict # doctest: +ELLIPSIS {'xbest':... We can also check the available attribute names like >>> es.result.names # doctest: +ELLIPSIS ['xbest', 'fbest',... and then check a value like >>> float(es.result.xbest[0]) < 10 True Otherwise, the result class acts largely like a `dataclass` and like the original `namedtuple` `CMAEvolutionStrategyResult`, however with _additional_ attributes: as of 2025 the `.best_feasible` attribute has been added. For backward compatibility, index access of the original entries is possible but discouraged, like >>> es.result[1] == es.result[-7] == es.result.fbest # deprecated True The nine result attributes are: ``xbest`` best solution evaluated, this may not reflect a good solution under noise or with a changing fitness function like in the constrained case. ``fbest`` objective function value of the best solution ``evals_best`` evaluation count when ``xbest`` was evaluated ``best_feasible`` is a dictionary with the keys ``'x', 'f', 'evals'`` (and possibly others), the feasible counterparts to ``xbest, fbest, evals_best``. This is particularly useful with constraints. ``best_feasible`` is not accessible by index. ``evaluations`` overall done ``iterations`` overall done ``xfavorite`` final distribution mean in "phenotype" space, considered to be the current best estimate of the optimum. ``stds`` effective final standard deviations, can be used to compute a lower bound on the expected coordinate-wise distance to the true optimum, which is (very!) approximately ``stds[i] * dim**0.5 * 3 / np.minimum(popsize, 3 * dim + 15)`` (was: ``stds[i] * dimension**0.5 / min(mueff, dimension) / 1.5 / 5 ~ stds[i] * dimension**0.5 / min(popsize / 2, dimension) / 5``, where dimension = CMAEvolutionStrategy.N and mueff = CMAEvolutionStrategy.sp.weights.mueff ~ 0.3 * popsize). ``stop`` termination conditions in a dictionary. CAVEAT: in contrast to a named tuple, this class iterates over items, not values, hence ``dict(es.result)`` works as expected. ``list(es.result)`` is not backward compatible (providing a list of values without keys seems rather pointless given the values are not homogenuous). The previous value of ``list(es.result)`` can be obtained by ``[r[1] for r in es.result]``. While not provided in this class, the (penalized-)best solution of the last completed iteration can be accessed via the attribute ``.pop_sorted[0]`` of `CMAEvolutionStrategy` and the respective objective function value via ``.fit.fit[0]``. Details: - in addition to ``._asdict()`` and ``dir(.)`` (which works rather poorly) for the old `CMAEvolutionStrategyResult`, viewing with ``dict(.)`` and ``.asdict`` works for this class too. - ``list(CMA.fit.idx).index(i)`` is the index of the i-ths sampled solution of the last completed iteration in ``pop_sorted``. In other words, it is the (original) index of the i+1-th best solution. Technical details: - The class allows to have new attributes while keeping backward compatible index access of the original eight attributes of the `namedtuple` `CMAEvolutionStrategyResult`. ``es.result[-8]`` still equals ``es.result[0]``. Newly introduced attributes are ignored in this count and cannot be accessed by position index. Index access is discouraged. - inheriting from a `list` would work too, but we would have the list methods as additional attributes. c  tt t fddD|_||_||_||_||_||_||_ ||_ ||_ | |_ |jD]\} } t|| | y)zHset attributes with the arguments resembling `namedtuple` or `dataclass`c3,K|] }||f ywrWr+).0name_varss r- z7CMAEvolutionStrategyResult2.__init__..s& # !"6:dE$K0 !"s) rerfrg best_feasiblerhrirjrkrlN)dictlocalstuple_paramsrerfrgrurhrirjrkrlsetattr) rArerfrgrurhrirjrkrlkvrss @r-r?z$CMAEvolutionStrategyResult2.__init__sVX # !" # #   $*&$"  LLDAq D!Q !r,cF|jDcgc]}|d c}Scc}w)zlist of attribute namesrry)rAps r-namesz!CMAEvolutionStrategyResult2.names-s$#ll+l!l+++s c"|jSrW)_asdictrAs r-asdictz"CMAEvolutionStrategyResult2.asdict2s||~r,c,t|jSrW)rvryrs r-rz#CMAEvolutionStrategyResult2._asdict6sDLL!!r,cz|tddvrtdj||dvr|j}|S|dvr|j}|S|dvr|j }|S|dvr|j }|S|dvr|j}|S|d vr|j}|S|d vr|j}|S|d vr|j}|Sd }|S) zyfor backward compatibility, access by the (old) index works too, this is supposed to stay as is forever. z{0} is not a valid result index, only -8...7 are valid and refer to 0=xbest,fbest,evals_best,evaluations,iterations,xfavorite,stds,7=stop)rr)ri)r"i)rE)))r#)N) r IndexErrorformatrerfrgrhrirjrkrl)rAiress r-r`z'CMAEvolutionStrategyResult2.__getitem__9s E"aL g%fQi) )'\tzz( ''\tzz ( %#$w,t ( #$%._s(!%$,,+W,Q,!%UYUaUa+bUaTQPQI,<,!) Zer,rnc eZdZdZedZy)_CMAEvolutionStrategyResultaDeprecated: A results tuple from `CMAEvolutionStrategy` property ``result``. This tuple contains in the given position - 0 best solution evaluated, ``xbest`` - 1 objective function value of best solution, ``f(xbest)`` - 2 evaluation count when ``xbest`` was evaluated - 3 evaluations overall done - 4 iterations - 5 distribution mean in "phenotype" space, to be considered as current best estimate of the optimum - 6 effective standard deviations, give a lower bound on the expected coordinate-wise distance to the true optimum of (very) approximately std_i * dimension**0.5 / min(mueff, dimension) / 1.2 / 5 ~ std_i * dimension**0.5 / min(popsize / 0.4, dimension) / 5, where mueff = CMAEvolutionStrategy.sp.weights.mueff ~ 0.3 * popsize. The penalized best solution of the last completed iteration can be accessed via attribute ``pop_sorted[0]`` of `CMAEvolutionStrategy` and the respective objective function value via ``fit.fit[0]``. Details: - This class is of purely declarative nature and for providing this docstring. It does not provide any further functionality. - ``list(fit.fit).find(0)`` is the index of the first sampled solution of the last completed iteration in ``pop_sorted``. c t|jj|j|j|j |j dd|jj|jfzS)zreturn a results tuple of type `CMAEvolutionStrategyResult`. `_generate` is a surrogate for the ``__init__`` method, which cannot be used to initialize the immutable `tuple` super class. N into_bounds) rbestrN countevals countiter to_phenotypemeanboundary_handlerrepairrkrs r- _generatez%_CMAEvolutionStrategyResult._generatesj+ IIMMO OO NN   diil*.*?*?*F*F  H II   r,N)r'r(r)r* staticmethodrr+r,r-rrus>  r,rc eZdZdZedZ d8dZd9dZdZd:d Z d9d Z d;d Z ddZ d9dZdZd?dZ d@dZ dAdZeje_d>dZdZdZd>dZdZdZ ed Z!ed!Z"ed"Z#ed#Z$ed$Z% dBd%Z&d&Z'd'Z(d(Z)d:d)Z*dCd*Z+ed+Z,dDd,Z-d-Z.d.Z/dEd/Z0d>d0Z1d1Z2d2Z3d3Z4ed4Z5d5Z6d9d6Z7d7Z8y)FCMAEvolutionStrategya?0CMA-ES stochastic optimizer class with ask-and-tell interface. Calling Sequences ================= - ``es = CMAEvolutionStrategy(x0, sigma0)`` - ``es = CMAEvolutionStrategy(x0, sigma0, opts)`` - ``es = CMAEvolutionStrategy(x0, sigma0).optimize(objective_fct)`` - :: res = CMAEvolutionStrategy(x0, sigma0, opts).optimize(objective_fct).result Arguments ========= `x0` initial solution, starting point. `x0` is given as "phenotype" which means, if:: opts = {'transformation': [transform, inverse]} is given and ``inverse is None``, the initial mean is not consistent with `x0` in that ``transform(mean)`` does not equal to `x0` unless ``transform(mean)`` equals ``mean``. `sigma0` initial standard deviation. The problem variables should have been scaled, such that a single standard deviation on all variables is useful and the optimum is expected to lie within about `x0` +- ``3*sigma0``. Often one wants to check for solutions close to the initial point. This allows, for example, for an easier check of consistency of the objective function and its interfacing with the optimizer. In this case, a much smaller `sigma0` is advisable. `opts` options, a dictionary with optional settings, see class `CMAOptions`. Main interface / usage ====================== The interface is inherited from the generic `OOOptimizer` class (see also there). An object instance is generated from:: es = cma.CMAEvolutionStrategy(8 * [0.5], 0.2) The least verbose interface is via the optimize method:: es.optimize(objective_func) res = es.result More verbosely, the optimization is done using the methods `stop`, `ask`, and `tell`:: while not es.stop(): solutions = es.ask() es.tell(solutions, [cma.ff.rosen(s) for s in solutions]) es.disp() es.result_pretty() where `ask` delivers new candidate solutions and `tell` updates the `optim` instance by passing the respective function values (the objective function `cma.ff.rosen` can be replaced by any properly defined objective function, see `cma.ff` for more examples). To change an option, for example a termination condition to continue the optimization, call:: es.opts.set({'tolfacupx': 1e4}) The class `CMAEvolutionStrategy` also provides:: (solutions, func_values) = es.ask_and_eval(objective_func) and an entire optimization can also be written like:: while not es.stop(): es.tell(*es.ask_and_eval(objective_func)) Besides for termination criteria, in CMA-ES only the ranks of the `func_values` are relevant. Attributes and Properties ========================= - `inputargs`: passed input arguments - `inopts`: passed options - `opts`: actually used options, some of them can be changed any time via ``opts.set``, see class `CMAOptions` - `popsize`: population size lambda, number of candidate solutions returned by `ask` () - `logger`: a `CMADataLogger` instance utilized by `optimize` Examples ======== Super-short example, with output shown: >>> import cma >>> # construct an object instance in 4-D, sigma0=1: >>> es = cma.CMAEvolutionStrategy(4 * [1], 1, {'seed':234}) ... # doctest: +ELLIPSIS (4_w,8)-aCMA-ES (mu_w=2.6,w_1=52%) in dimension 4 (seed=234...) and optimize the ellipsoid function >>> es.optimize(cma.ff.elli, verb_disp=1) # doctest: +ELLIPSIS Iterat #Fevals function value axis ratio sigma min&max std t[m:s] 1 8 2.09... >>> assert len(es.result) >= 8, es.result >>> assert es.result.fbest < 1e-9, es.result The optimization loop can also be written explicitly: >>> es = cma.CMAEvolutionStrategy(4 * [1], 1) # doctest: +ELLIPSIS (4_w,8)-aCMA-ES (mu_w=2.6,w_1=52%) in dimension 4 (seed=... >>> while not es.stop(): ... X = es.ask() ... es.tell(X, [cma.ff.elli(x) for x in X]) ... es.disp() # doctest: +ELLIPSIS Iterat #Fevals function value axis ratio sigma min&max std t[m:s] 1 8 ... achieving the same result as above. An example with lower bounds (at zero) and handling infeasible solutions: >>> import numpy as np >>> es = cma.CMAEvolutionStrategy(10 * [0.2], 0.5, ... {'bounds': [0, np.inf]}) #doctest: +ELLIPSIS (5_w,... >>> while not es.stop(): ... fit, X = [], [] ... while len(X) < es.popsize: ... curr_fit = None ... while curr_fit in (None, np.nan): ... x = es.ask(1)[0] ... curr_fit = cma.ff.somenan(x, cma.ff.elli) # might return np.nan ... X.append(x) ... fit.append(curr_fit) ... es.tell(X, fit) ... es.logger.add() ... es.disp() #doctest: +ELLIPSIS Itera... >>> >>> assert es.result.fbest < 1e-9, es.result >>> assert es.result.evals_best < 9000, es.result # by internal termination >>> # es.logger.plot() # will plot data >>> # cma.s.figshow() # display plot window An example with user-defined transformation, in this case to realize a lower bound of 2. >>> import warnings >>> with warnings.catch_warnings(record=True) as warns: ... es = cma.CMAEvolutionStrategy(5 * [3], 0.1, ... {"transformation": [lambda x: x**2+1.2, None], ... "ftarget": 1e-7 + 5.54781521192, ... "verbose": -2,}) >>> warns[0].message # doctest:+ELLIPSIS UserWarning('in class GenoPheno: user defined transformations have not been tested thoroughly (... >>> warns[1].message # doctest:+ELLIPSIS UserWarning('computed initial point... >>> es.optimize(cma.ff.rosen, verb_disp=0) #doctest: +ELLIPSIS >> assert cma.ff.rosen(es.result.xbest) < 1e-7 + 5.54781521192, es.result >>> assert es.result.evals_best < 3300, es.result The inverse transformation is (only) necessary if the `BoundPenalty` boundary handler is used at the same time. The `CMAEvolutionStrategy` class also provides a default logger (cave: files are overwritten when the logger is used with the same filename prefix): >>> es = cma.CMAEvolutionStrategy(4 * [0.2], 0.5, {'verb_disp': 0}) >>> es.logger.disp_header() # annotate the print of disp Iterat Nfevals function value axis ratio maxstd minstd >>> while not es.stop(): ... X = es.ask() ... es.tell(X, [cma.ff.sphere(x) for x in X]) ... es.logger.add() # log current iteration ... es.logger.disp([-1]) # display info for last iteration #doctest: +ELLIPSIS 1 ... >>> es.logger.disp_header() Iterat Nfevals function value axis ratio maxstd minstd >>> # es.logger.plot() # will make a plot Example implementing restarts with increasing popsize (IPOP): >>> bestever = cma.optimization_tools.BestSolution() >>> for lam in 10 * 2**np.arange(8): # 10, 20, 40, 80, ..., 10 * 2**7 ... es = cma.CMAEvolutionStrategy(6 - 8 * np.random.rand(4), # 4-D ... 5, # initial std sigma0 ... {'popsize': lam, # options ... 'verb_append': bestever.evalsall}) ... # logger = cma.CMADataLogger().register(es, append=bestever.evalsall) ... while not es.stop(): ... X = es.ask() # get list of new solutions ... fit = [cma.ff.rastrigin(x) for x in X] # evaluate each solution ... es.tell(X, fit) # besides for termination only the ranking in fit is used ... ... # display some output ... # logger.add() # add a "data point" to the log, writing in files ... es.disp() # uses option verb_disp with default 100 ... ... print('termination:', es.stop()) ... cma.s.pprint(es.best.__dict__) ... ... bestever.update(es.best) ... ... # show a plot ... # logger.plot(); ... if bestever.f < 1e-8: # global optimum was hit ... break #doctest: +ELLIPSIS (5_w,... >>> assert es.result.fbest < 1e-8, es.result On the Rastrigin function, usually after five restarts the global optimum is located. Using the `multiprocessing` module, we can evaluate the function in parallel with a simple modification of the example (however multiprocessing seems not always reliable): >>> from cma.fitness_functions import elli # cannot be an instance method >>> from cma.optimization_tools import EvalParallel2 >>> es = cma.CMAEvolutionStrategy(22 * [0.0], 1.0, {'maxiter':10}) # doctest:+ELLIPSIS (6_w,13)-aCMA-ES (mu_w=... >>> with EvalParallel2(elli, es.popsize + 1) as eval_all: ... while not es.stop(): ... X = es.ask() ... es.tell(X, eval_all(X)) ... es.disp() ... # es.logger.add() # doctest:+ELLIPSIS Iterat... The final example shows how to resume: >>> import pickle >>> >>> es0 = cma.CMAEvolutionStrategy(12 * [0.1], # a new instance, 12-D ... 0.12) # initial std sigma0 ... #doctest: +ELLIPSIS (5_w,... >>> es0.optimize(cma.ff.rosen, iterations=100) #doctest: +ELLIPSIS I... >>> s = es0.pickle_dumps() # return pickle.dumps(es) with safeguards >>> # save string s to file like open(filename, 'wb').write(s) >>> del es0 # let's start fresh >>> # s = open(filename, 'rb').read() # load string s from file >>> es = pickle.loads(s) # read back es instance from string >>> # resuming >>> es.optimize(cma.ff.rosen, verb_disp=200) #doctest: +ELLIPSIS 200 ... >>> assert es.result.evals_best < 15000, es.result >>> assert cma.s.Mh.vequals_approximately(es.result.xbest, 12 * [1], 1e-5), es.result >>> assert len(es.result) >= 8, es.result Details ======= The following two enhancements are implemented, the latter is only turned on by default for very small population sizes. *Active CMA* is implemented with option ``CMA_active`` and conducts an update of the covariance matrix with negative weights. The negative update is implemented, such that positive definiteness is guarantied. A typical speed up factor (number of f-evaluations) is between 1.1 and two. References: Jastrebski and Arnold, Improving evolution strategies through active covariance matrix adaptation, CEC 2006. Hansen, The CMA evolution strategy: a tutorial, arXiv 2016. *Selective mirroring* is implemented with option ``CMA_mirrors`` in the method `get_mirror` and `get_selective_mirrors`. The method `ask_and_eval` (used by `fmin`) will then sample selectively mirrored vectors within the iteration (``CMA_mirrormethod==1``). Otherwise, or if ``CMA_mirromethod==2``, selective mirrors are injected for the next iteration. In selective mirroring, only the worst solutions are mirrored. With the default small number of mirrors, *pairwise selection* (where at most one of the two mirrors contribute to the update of the distribution mean) is implicitly guarantied under selective mirroring and therefore not explicitly implemented. Update: pairwise selection for injected mirrors is also applied in the covariance matrix update: for all injected solutions, as for those from TPA, this is now implemented in that the recombination weights are constrained to be nonnegative for injected solutions in the covariance matrix (otherwise recombination weights are anyway nonnegative). This is a precaution to prevent failure when injected solutions are systematically bad (see e.g. https://github.com/CMA-ES/pycma/issues/124), but may not be "optimal" for mirrors. References: Brockhoff et al, PPSN 2010, Auger et al, GECCO 2011. :See also: `fmin` (), `OOOptimizer`, `CMAOptions`, `plot` (), `ask` (), `tell` (), `ask_and_eval` () c.|jjS)z:number of samples by default returned by `ask` () )sppopsizers r-rzCMAEvolutionStrategy.popsizeswwr,r+FNc|rs|jdkDrd|jdrU|jdt|jdk7r-tj|jd||_||j _|j ||xs+|xs'|xr#|j|j jk7}|r|D]}|j|d|r(|j jdc}|j _ |S)a return the termination status as dictionary. With ``check == False``, the termination conditions are not checked and the status might not reflect the current situation. ``check_on_same_iteration == False`` (new) does not re-check during the same iteration. When termination options are manually changed, it must be set to `True` to advance afterwards. ``stop().clear()`` removes the currently active termination conditions. As a convenience feature, keywords in `ignore_list` are removed from the conditions. If `get_value` is set to a condition name (not the empty string), `stop` does not update the termination dictionary but returns the measured value that would be compared to the threshold. This only works for some conditions, like 'tolx'. If the condition name is not known or cannot be computed, `None` is returned and no warning is issued. Testing `get_value` functionality: >>> import cma >>> es = cma.CMAEvolutionStrategy(2 * [1], 1e4, {'verbose': -9}) >>> with warnings.catch_warnings(record=True) as w: ... es.stop(get_value='tolx') # triggers zero iteration warning ... assert len(w) == 1, [str(wi) for wi in w] >>> es = es.optimize(cma.ff.sphere, iterations=4) >>> assert 1e3 < es.stop(get_value='tolx') < 1e4, es.stop(get_value='tolx') >>> assert es.stop() == {} >>> assert es.stop(get_value='catch 22') is None rtermination_callbackN) roptsstrrListOfCallables callbackstop _stopdict _get_valuelastiterpop_value)rAcheck ignore_listcheck_in_same_iteration get_valuerrOs r-rlzCMAEvolutionStrategy.stopsF dnnq(TYY7M-N 01SCY9Z5[[ X 5 5dii@V6W XY] ^D $-!nnT#:$Xi$X#(#VT^^t~~?V?V-VY "T"# )-)>)> &C& r,c,tjdtj|r||}~tt _j d=|i}|_t|j}|jdtd|d<|jdxt_ }|dkrd|d<d|d <d|d <d |vr|jd r td d |vr|jd r tdj|tj_tj"|rtdj%|t'j(|dk7st'j*|rtdj%|t-|_j._j }tj"|drt3j4|d|d<t7|dts|dJt7|dtrj t|dz }|j9t t'j:|drd|d<|_tj>|dsBj<dt&j@jBur|dr(|dtDustG|djIdrt&j@jKtEjDdtEjDdzzz }tMdt&j@jOz|zdtEjDdzzz|d<t&j@jK|dn1|ddtDfvr$tjPdtG|dztSjTj |d|d|d|d_+jVjXs)t[j\dj%dt^|d _0t7j`tbrja|d!_0n0|d!dd"gd#fvs|d!d|d!dt[j\d$j`jestg_0nuj`jijs|ddk\rωj`jkj} t[j\d%t| dkDrd&nd'd(tG| d)tGjVjmjd*tGj`jndd+tGj`jndd, |d-Vj`jqd.j j`jqd/j z |d0z|d-<j`js|d1jVjt} jVjvr?jVjt)d2} | jV_:t[j\d3jVjyt'jzjd4j`j|d"5_?t'jzj~d4_@t{j~d4_A| jV_:tj~_B|jk(sJ|j||tj|||ddkD6_Fj_Gd7} | |d8_Ht7jts|d9rdnd"_Jd}fd; } | |d<||d|d<<| |d-||t&j|d-<t|d1rA|j|jjjt_Pn t_Pd=d>krEt|d1r7 dd?lRmS}tjd@}t[j\|t^d_VdA_Wt7|dBtstd|dBfnd_Zt'j|_\t'j|_]t'j|_^dd>kr| j<dC||__t'j(jdk(r7j<dDr(xjt'j|zc__tSjj_bt'jj<dErىxjt'j|zc_bn| j<dC||_bt'jj<dEr(xjt'j|zc_bt'jjr jnjj__j<drtj|j<dF_hjjj<ddurSjjj|jjjjd"Gnj<ddk(r tdHjjj|jjjjn| j<dI||}d=d>kr9tj<dJdKr dLj<dJvrdj<dM<j<dNBtj|t'j|zj<dOCd:jjjjzdPzz jz dQz nj<dOj<dMj<dj<dRS_hjjjjjjjjT}jjj||dU|dVnqt7j<dNtbr@ j<dN|t'j|zfij<dW_hnj<dN_ht7jtjsXtjPdZtGtctjd[tGtcjd\jjj|dkD]jj_xjd^z_yg_zg_{d_|d_}g_~jVjmj~j0jzjzzjVjmj~j0jzjzz z d_z j`jqd.j j`jqd/j z z }t'j|dkDret'j|dkDd}d`t|dkDrdadbtG|zfndcddtG|dzfz}t[j\|d_j_d_d_g_ jj tt_ tSjj<t_ ttjjdeknt_ t#_t'j(_t-_|d^zdd:df|zz z d:dg|dhzzz zzj._t3|di|d |djkj5_t9_ t=j~_d#_ t-_djB_djB_djB_djB_gjB_tMjB_tMjB_djB_djB_t&jjB_t&jjB_djB_djB_tj^_|ddkDr|ddk\r jjjbdkDrdlndm}jjdrdnjjdzndm}tgdojjjbz|zdpjjzz|zdqz|drrdsndmzdtzdujjjtMdvjjdzfzzdw|tG|dtEjhfzz|drډjjjrdm}|ddurdx}|dt&jkr|tGtM|dz }n%|tGt'jl|dz }|dyz }|dztGtod:jjjjzz zd{zz }tgd||zyyyyy#t$rY wxYw#t|t|kDrtjPdXn#|ddk7rtjPdY|dzj<dN|fij<dW_hYxYw#t$rYLwxYw)~zsee class `CMAEvolutionStrategy` `options` is for consistency with `fmin2` options and is only in effect if ``inopts is None``. oncecategoryNrAverboserr verb_dispverb_log verb_plotnoise_handlingzOnoise_handling not available with class CMAEvolutionStrategy, use function fminrestartszIrestarts not available with class CMAEvolutionStrategy, use function fminzCsigma0 must be a scalar, a string like '{0}' is no longer permittedrzinput argument sigma0 was {0} but must be (or evaluate to) a scalar, use `cma.ScaleCoordinates` or option `"CMA_stds"` when different sigmas in each coordinate are in order.fixed_variables CMA_diagonalTseedrandntimeg.Agj@zSseed=%s will never be used (seed is only used if option 'randn' is np.random.randn)scaling_of_variables typical_xtransformationa"genotype-phenotype transformations induced by {0} may not be compatible with more recently introduced code features (like integer handling) and are deprecated. Rather use an objective function wrapper instead, see e.g. `ScaleCoordinates` or `FixVariables` in `cma.fitness_transformations`.z opts['scaling_of_variables'], opts['typical_x'], opts['fixed_variables'], opts['transformation'])BoundaryHandlerboundsFr+z Option 'bounds' ignored because a BoundaryHandler *instance* was found. Consider to pass only the desired BoundaryHandler class. zX Initial solution is out of the domain boundaries in indicesex z: x0 = z ldom = z udom = zR THIS MIGHT LEAD TO AN EXCEPTION RAISED LATER ON. maxstdupperlowermaxstd_boundrangeinteger_variablesc|SrWr+xs r-identityz/CMAEvolutionStrategy.__init__..identitysr,zucomputed initial point may well be wrong, because no inverse for the user provided phenotype transformation was givencopy from_boundsrrc2|tjdt}n@|dur.|jddur|jdkDrt }nt}n|dur t }t|tr(||j|jj}|S)z+return instantiated sigma adaptation objectzValue `None` for option 'AdaptSigma' is ambiguous and hence deprecated. AdaptSigma can be set to `True` or `False` or a class or class instance which inherited from `cma.sigma_adaptation.CMAAdaptSigmaBase`Tri+F) dimensionr) r print_warningCMAAdaptSigmaCSArNCMAAdaptSigmaTPACMAAdaptSigmaNone isinstancetyperr) adapt_sigmarAs r-instantiate_adapt_sigmaz>CMAEvolutionStrategy.__init__..instantiate_adapt_sigmas"##?@ / $99^,4#"2K"2K%/1 +t,)DFFDGGOOT  r, AdaptSigmamean_shift_line_samples?c||Stj|dk(r t|d}n|drtj||kDrzt t t |Dcgc]}||dvr||c}t}t ||k7rtjdt ||fzdjnR|r?t ||kr1tj||t |z |dgzft}nt |t}tj|d|fvr#td |tj|fz|S#t$rt|}YTwxYwcc}w) zvreturn `default_value` as scalar or `in_` after removing fixed variables if ``len(in_) == N`` rrrdtypezresulting len %d != N = %d eval_vectorrFrzEvector (like CMA_stds or minstd) must have dimension %d instead of %d) npsizefloat TypeErrorr rrrrr concatenate ValueError)in_rr default_valuerrrAs r-rz2CMAEvolutionStrategy.__init__..eval_vectorsn{$$wws|q %A-C'(RWWS\A-=U3s8_I_'(5F0G'G!V_I"')s8q=''4C!}D%As3x!|nncACLSWI+E%F+02Cu-wws|Aq6) 145rwws|3DEFFJ'!%*C%IsE&E/E,+E,minstd rE)integerzzOption 'integer_variables' is discouraged. Use class `cma.integer.CMAIntMixed` or function `cma.integer.fmin_int` instead.r verb_appendCMA_stdsCMA_diagonal_decodingCMA_dampsvec_fac)r)pos_defzOption 'CMA_diagonal' == 1 is disallowed. Use either `True` or an iteration number > 1 up to which C should be diagonal. Only `True` has linear memory demand. CMA_teststdsvvr` sweep_ccovCMA_const_trace CMA_sampler updatecovwaitQ@-(;rDCMA_eigenmethod)lazy_update_gapconstant_tracer eigenmethodmuefflamc1cmuCMA_sampler_optionsz`different initial standard deviations are not supported by the current sampler and hence ignoredz6ignoring scaling factor %f for sample distributionzEstatistical model sampler did not evaluate to the expected type `z` but to type `z8`. This is likely to lead to an exception later on. )warnrGg5^I @zValueWarning: Initial standard deviation%s larger than the bounded domain size in variable%s. Consider using `cma.ScaleCoordinates` if the bounded domain sizes differ significantly. zs sigma0 x stds arezs %sz sigma0 x stds isz %s!g@g5@r"verb_filenameprefixverb_log_expensive)moduloexpensive_modulo_wzmirr%dz(%dz,%dz)- CMA_activeazCMA-ESz (mu_w=%2.1f,w_1=%d%%)dz in dimension %d (seed=%s, %s)z for z iterationsz (1/ccov=)z Covariance matrix is diagonal)r) _cma_warnings filterwarningNeverTestedWarningrvrw inputargsinoptsr complementevalrglobal_verbosityr_set_x0rx0N_phenois_strrrrshapersigma0sigmaast literal_evalrevalallisinfris_nanrandomrrr startswithrintrandrr GenoPhenogp isidentitywarningsr DeprecationWarningrr has_boundsr is_in_boundsidx_out_of_boundsrHr get_bounds"amend_bounds_for_integer_variablestf_genotf_phenorIr inversermean_after_tellmean0ramend_integer_optionsr CMAParametersrsp0rrmean_shift_samplesrset_integer_min_stdweightsrrinteger_centeringr5r'r format_message ImportErrorr_isotropic_mean_shift_iterationboolmaxrzerospcpc2pc_neg sigma_vec0onesDiagonalDecoding sigma_vecisfiniteisscalarrrGaussStandardConstantsm_updateBDfromSMfinalize_negative_weightsc1_sepcmu_seprrhasattrGaussFullSampler parameterslambda_minr ,StatisticalModelSamplerWithZeroMeanBaseClass_stds_into_limits variancesdCDpop_injection_solutionspop_injection_directionsnumber_of_solutions_askednumber_of_injections_delivered_is_independent_sampleanynonzero _flgtelldoneitereigenupdated count_eigennoiseShsiglist initialize Exceptionr:archive_sent_solutionssent_solutionsRoundIntegerVariablesround_integer_variables_round_integer_variablesarchive_after_sentrarchive _SolutionDict_injected_solutions_archiveot BestSolutionr _BlancClassconstchiNrregisterlogger _CMAStopDictr_StopTolXStagnation_stoptolxstagnationrfitbndpen fit_plus_penidxhistlisthistbest histmedianmedianmedian0 median_minmedian_previousmedian_got_worseflatfit_iterations MoreToWrite more_to_writemulam_mirrprintasctimeCMA_onfloorround)rAr5r9r0optionsrr3r six_decimalsidxstf_geno_backuprrrr srkr relative_stdsr sweightedsmirrs` r-r?zCMAEvolutionStrategy.__init__st ##F-:-M-M O v~F fh NN6 " >F &!,,. 99Y  '(l95DO48IIi4HH!1 b !D  D  !D  t # 2B(Cno o  $))J"7hi i R477| << biijpqr r 776?a 288F#3R%fVn. .Fm [[  LL <<./ 0&)&6&6*+'-D" #4 12D9%&. 0/ d,-t 4 s4(9#:;;A VX 88D( )#'D  ||DL)yy!RYY__4F|tF|t';s4 ?a'00BB477KDMM"%TQvD8D DGGMM$''23D1188;<D1188;< #> ?H~%"&"7"7"B"B7DLL"Y"&"7"7"B"B7DLL"Y#Z&*+>&?"@X  ! ! D D,- / 77   7 &DGGO MM GGLL$''!=(,(=(=(E(E!&!(  "xx =49940 (TYYDFF{{ ""1f-$221dDOVWDWX77 (34 3EtL+5d6F6FHX+Y * +#'27  <%T(^T1a@X$T(^T1bffEX t'( )  $ $Q(=(= >%5d%;D "%*D " 6c$234 %((67 a*<= /1,d=148q$}"567>? ((1+88A;hhqk q5)$))J*?qIDOwwt'1,;R1S2771:-,==dooNDN{{499%789"''!*,(:)>aHDN{{499%789"''!*,02 DNN0Kdnn151D1D1F O 99^ $33ATYYw=OPDG   )yy(D099!6:ggnn6:ggoo>C:E>*a/ "9::99!6:ggjj6:ggkkCtyy8$BDAv499T?M:$ $737DII/0yy'/!224"''!*3D 99_5=dggjj477;;6>?$&&H2M!YY7#'99->#?))G, $ *; <GG&&TWW__-B-B+/77??+B+B'D99!QtWahODIIm4d; D6dii 6 $rwwqz 1D"&)),A"BDDG))M2dggz'^'^_##ZTTUVTWW & %()   ) $4q$89''###')$(*%)*&./+&(#''-- DJJ4ORVRXRX4X(XY GGMM$))djj4>>6QTXTZTZ6Z*Z[\_de 11<>w UVW  66-!# $**]Q./2C 3x!|+FSX,=>*=*/#c!f+*=*?  @  MM!   $       ' ' -J12HIK ')8(M(M II'>)@%  D*2D2L,077??R+?0BDF  I+8?(OO%  ] S&Abd ObC1Ho$EF #D)>$?+/ +;59:N5OQQYQYZ^Q_ &>#6tyy#A L=  $   F"f ff#%66 $%!&'#"..0  q T)_%9 $ 2 2Q 6BI59WW5E5EH 0 012E %477??--.:Udggoo=VVY^^!%l!3#=?GH*dggoo.C.CStww_`OaIaEb-ccd3aT&\9JDLLN5[[\ ]N#'t3AN+bff4ST.%9!:;;S$~*>!?@@&As5twwzzDGGKK7O1P+Q'RRUXXXA81<=)7#&: M  B D4y3t9,++-9:aA++-!%a-)*6dii 6qD"&)),A"BDDGV   s?6AW>AWC5AYW AW W AW WA:AY Y AYYAYc |}t |t d|_|j jdk(rd|j jvrtjdt|j jzdz|j jddk(r|j d|_nG|j jddk(r+t |j Dcgc]}|d c}|_|j jdk7r td t|j dkr+tjd t|j z |j j|j jdy #t$r$tj|r tdYwxYwcc}w#t$rYy wxYw) aAssign `self.x0` from argument `x0`. Input `x0` may be a `callable` or a `list` or `numpy.ndarray` of the desired length. Below an artificial example is given, where calling `x0` delivers in the first two calls ``dimension * [5]`` and in succeeding calls``dimension * [0.01]``. Only the initial value of 0.01 solves the Rastrigin function: >>> import cma >>> class X0: ... def __init__(self, dimension): ... self.irun = 0 ... self.dimension = dimension ... def __call__(self): ... ... self.irun += 1 ... return (self.dimension * [5] if self.irun < 3 ... else self.dimension * [0.01]) >>> xopt, es = cma.fmin2(cma.ff.rastrigin, X0(3), 0.01, ... {'verbose':-9}, restarts=1) >>> assert es.result.fbest > 1e-5 >>> xopt, es = cma.fmin2(cma.ff.rastrigin, X0(3), 0.01, ... {'verbose':-9}, restarts=2) >>> assert es.result.fbest < 1e-5 # third run succeeds due to x0 z9x0 may be a callable, but a string is no longer permittedT)rrr"rz:input x0 should be a list or 1-D array, trying to flatten z-arrayrzx0 must be 1-D arrayzInitial solution argument x0=%s is 1-dimensional. Optimization in 1-D is not supported and may bail or work poorly. See issues https://github.com/CMA-ES/pycma/issues/86 and https://github.com/CMA-ES/pycma/issues/302.N)rrr7rr rr5ndimr8rrrresizeNotImplementedError)rAr5rs r-r4zCMAEvolutionStrategy._set_x0s: ^B %d3 77<<1 dggmm!3    \ #DGGMM 2!35=!> ?ww}}Q1$''!*q!Q&tww 7w!1w 78 77<<1 34 4 tww<1    !K#&dgg,!/ 0  GGNN477==+ ,) ^||B !\]]  ^!8#   s)F) G )2G)G G  GGc tj|jddkD}tjtj|jd}|jdkrtj dnd} |s|syd}g}t |jD]Y\}}d } |r||jd|} || k} |r | s||jd|} || |zkD} | sK|jj|j|dk(s/tj|jj| zsItjd j||jj| |jnS|jj||jj|| z|z |j |xx| |z zcc<|sD|j#|| |z f\|rs|d\}} tjd j||j| |j|d jt%|dkDrt%|dz nd yy)zIset ``self.sigma_vec.scaling`` to respect ``opts['max/minstd']`` rrrr"g-C6?rNc:tj|r|S||SrW)rrh)bndsrs r-get_iz5CMAEvolutionStrategy._stds_into_limits..get_is{{4  7Nr,Fzo_stds_into_limits: sigmavec update omitted due to an inadmissible value s={0}, scaling[i]={1}, sb={2}, stds={3}zXSampling standard deviation i={0}{4} at iteration {1} multiplied by {2} to stds[{0}]={3}z (and {0} others)r')rr~rrgrexp enumeraterkrf_init_rscalingrGr rset_iraappendr) rAr is_minis_maxinitial_linalg_fixr warning_datarrfoundsbsss r-ruz&CMAEvolutionStrategy._stds_into_limitss& (+a/0 DIIh$789-1^^q-@RVVD\aBf   dii(DAqE499X.2Be499X.2B!333%%dff-6T^^-C-CA-F-K!LMM#X4>>#9#9!#$>'*<'81'<@C>> import cma >>> es = cma.CMAEvolutionStrategy(3 * [1], 0.1, ... {'bounds':[0,9], 'verbose':-9}).optimize(cma.ff.elli, iterations=10) >>> es2 = es._copy_light() >>> assert es2.sigma == es.sigma >>> assert not sum((es.sm.C - es2.sm.C).flat > 1e-12), (es.sm.C, es2.sm.C) >>> assert not sum((es.sm.C - es2.sm.C).flat < -1e-12), (es.sm.C, es2.sm.C) >>> es3 = es._copy_light(sigma=3) >>> assert es3.sigma == es3.sigma0 == 3 >>> es.mean[0] = -11 >>> es4 = es._copy_light(inopts={'CMA_on': False}) >>> assert es4.sp.c1 == es4.sp.cmu == 0 >>> assert es.mean[0] == -11 and es4.mean[0] >= -4.5 Nr) r:rvr0updaterrErHrrr _set_C_from)rAr:r0ress r- _copy_lightz CMAEvolutionStrategy._copy_light s4 =JJEDKK    KK  T$Z diil262G2G2N2N&Pt% t r,cP|j|jk7r9tjdj|j|j|r~t j |j j|_tj|jdk(s.tjdj|j |jjj|j_ tj|jdk(s/tjdj|j |jj!d|j#y#t$rtjdYLwxYw)zset the current covariance matrix from another class instance. If `scaling`, also set the diagonal decoding scaling from `es.sigma_vec`. This method may not work as expected unless the default sampler is used. zTsetting C with dimension {0} != {1} (the current dimension). This is likely to fail.rz>self.pc2={0} != 0 may not be compatible with changed sigma_vecz5self.pc={0} != 0 may not be compatible with changed Cz#`self.sm.C = es.sm.C.copy()` failedrN)rrGr rr rerfrrallrarjCrr`r update_nowrk)rArrs r-rz CMAEvolutionStrategy._set_C_from0s 44466> MM@!6"$$/ 1 ,==bll>R>RSDN66$((a-( ^%vdhh/1 0 DGGI66$''Q,' U%vdgg0 2  A MM? @ As3FF%$F%rc jdk\sJjdk(rtj_njjj |||fi|}|Dcgc]4}j j|djj6} }|]tjtjs$tjdddjd tj d t"j$  j j&stjd fd d*fd } d*d} j(jk(r/tjdjj*dj_t/dt1| dz f} dj2| <| j8}j j|djj}||g|}j j:r&jjj=rdd}tjt>rjjnztjt@rfd}| ||}nKjtjtBrn$tEdtGjzdzfd}| ||}||z|z}j*dr%tj dt"j$ t1|jHk7r8tj dj7t1|jHjjJtMjNjjPjRjT|zz}tW|dz}|r|jXjH|z dzzjTtMjNjjPjjJ|zzzz || <ddkrɉj*d rtWtMjNjjPjRjTd!z|zjjJz dz}|r%|jXjH|z dzz|zz n||| <n&||| <tjd"j#j j|| djj| | <ddkrut[d$| | j8z t[d%| | j8z t[d&|t[d'| | j8z |z tW|dzdzz t]|D]0}j^ja| |||j)2jbje| | Scc}w#t,$rYwxYw#t4$r0} tj dj7| | Yd} ~ d} ~ wwxYw#t,$r.} tj d(j7| Yd} ~ d} ~ wwxYw)+aget/sample new candidate solutions. Solutions are sampled from a multi-variate normal distribution and transformed to f-representation (phenotype) to be evaluated. Arguments --------- `number` number of returned solutions, by default the population size ``popsize`` (AKA ``lambda``). `xmean` distribution mean, phenotyp? `sigma_fac` multiplier for internal sample width (standard deviation) `gradf` gradient, ``len(gradf(x)) == len(x)``, if ``gradf is not None`` the third solution in the returned list is "sampled" in supposedly Newton direction ``np.dot(C, gradf(xmean, *args))``. `args` additional arguments passed to gradf `kwargs` if `ignore_integer_variables` do not change integer variables at all which is in particular useful when a small mutation is added to a given solution and integer values are not supposed to be disturbed at all and/or moved across a plateau boundary. Return ------ A list of N-dimensional candidate solutions to be evaluated Example ------- >>> import cma >>> es = cma.CMAEvolutionStrategy([0,0,0,0], 0.3) #doctest: +ELLIPSIS (4_w,... >>> while not es.stop() and es.best.f > 1e-6: ... X = es.ask() # get list of new solutions ... fit = [cma.ff.rosen(x) for x in X] # call fct with each solution ... es.tell(X, fit) # feed values :See: `ask_and_eval`, `ask_geno`, `tell` rTrrNzSGradient injection may fail, because sampler attributes `B` and `D` are not presentaskrrmaxwarnszthe `gradf` argument to `ask` has not been thoroughly tested, consider to use ``es.inject(es.mean - delta * gradf(es.mean)`` with a large value for delta.rz using the gradient (option ``gradf``) with a non-linear coordinate-wise transformation (option ``transformation``) has never been tested.cjds|Stjtt |Dcgc]}|jdvr||c}Scc}w)z9return y unchanged or a copy of y without fixed variablesr)rrasarrayrr)yrrAs r- _rm_fixedz+CMAEvolutionStrategy.ask.._rm_fixedsf99%67 ::U3q6]'Q]*+499=N3O*O()t]'QRR'QsAct|ddt|zzn|}|||z|||z z d|zz S)zmap is a coordinate-wise independent map, return the estimated diagonal of the Jacobian. :0yE>rr")abs)rmapepsilonepsrs r- grad_numerical_of_coordinate_mapzBCMAEvolutionStrategy.ask..grad_numerical_of_coordinate_mapsF29$!c!f*-gC$SS\CCL%@AQWMMr,c(|ddt|zzn|}tjt|}tjt|}t |D]2}||||<|||z|||z z d||zz ||<d||<4|S)zLreturn symmetric numerical gradient of func : R^n -> R. rrr"r)rrr_rr)rfuncrrgradeirs r-grad_numerical_symz4CMAEvolutionStrategy.ask..grad_numerical_syms29$!c!f*-gC88CF+D#a&)B"1X #A1#'B<$q2v,#>1SV8"LQ !1& Kr,z0gradient is used several times in this iterationr)rFrr"Fz6Exception {0} when setting _is_independent_sample[{1}]c~jj|tt|d|iijS)NrI)r__call__rrxrE)rrAs r-fpenaltyz*CMAEvolutionStrategy.ask..fpenaltys;#'#8#8#A#A !=%(VQK1H#I477$TTr,z unknown boundary handling methodz when using gradfc>jj|S)Nr)rErH)rboundary_repairrAs r-_gp_for_num_gradz2CMAEvolutionStrategy.ask.._gp_for_num_grads#ww}}QO}LLr,rzgradient with fixed variables was never tested, consider to implement a simple transformation of the objective instead see `cma.fitness_transformations.FixVariables`zSgradient dimension={0}!={1}=genotype dimension.This will lead to an exception soon.rGrrErrzgradient zero observedrzx/mz x-m=z g=z (x-m-g)/||g||=z,Gradient injection failed with exception {0}rIrFrW)3rr ElapsedWCTimetimerticask_genorErHrrrrjrrprrGr r,r.islinearlast_iteration_with_gradientrAttributeErrorrsrr}rrrrFrIrrrrrrrxrdotBTrfsumr:rrrrRrround_population)rAnumberxmean sigma_facgradfr3r4pop_genor pop_phenorrindex_for_gradientexpheno grad_at_meangradpenrrgradgpr|qrrrs` @@r-rzCMAEvolutionStrategy.askNsx`~~""" >>Q ,,.DJ JJNN 4== DVD"*+!)AWW]]14/3/D/D/K/K#M!) +  dggw'?'?@##%U$)+A$(NNQ@ MM1'99 ;w Xww'''')./ R N  88DNNJ++-1<@NN,0IIi,@B9=D5&)!S^A-=)>%?"DFKD//0BC= IIEu4373H3H3O3O'Q(v)=)=> ww))d.C.C.O 11<<>&*OG!$"7"7H*.*?*?*F*F#D$9$9$02T#,,>uh,O"P..6&t'<'<(131> 5 567/011M=eEUVF#/W#BL99./MM#M"/!A!AC|$.MM#I#)6#l*;TVV#DFGGIItwwyy{{DNN\4Q RR1I384::#'66A:"3<4#'>>BFF47799dggiiRSm4T#TJ@K8K&+!!3449H/0''(@26..B15 /0t $ 5 5 < <1>1> ,-6%+=!>!JK(%&89DIIEG(L109=O3PSWS\S\3\_k3korsBCtCpDFIpI3IJ "A    & &y|(1+26.. ' B#$ %%66yAy+f& !DMM"Z%+VA/A%BDDDV" X LSSTUVWW Xsn-9Y#:Z4AY(-Z4Y8P2Z4( Y51Z44Y55Z48 Z1%Z,&Z4,Z11Z44 [+=$[&&[+cr||dkr|jj}|jdk(r0t|jt|j z|_|jdrB|j|jdd|j|jdd|}| |j}n |j|d}ddkrC|jd r4|jdk(r d |_|j j#|}|S||j$z}|jrd |_g|_g}|dkDr|!t)j*||jr|jd krt|j|jd z kDrgt-j.d t|j|jfzdt|jd zzz|jdk(rdndz|jrt||k\rn|jj1d} |j3| |j4dz|jdzkDr|j7| } nd} | | |j$z z} |j9| |jr|j rQ|j9|j j1d|jz |j$z |j rQ|j:r|jdkDst|dkDrt|d kr t=d|dxx|j7|d|j$z zcc<|dxxt?j@|dd zt?j@|dd zz dzzcc<t)j*|d|d s;t-jBddd|j} | xrtEjF| |xjHt|z c_$|jd ks|j:r|jHd k\sJ|t|z } | dkDr|jJt?jL|jNjQ| z} |jS|jN|r1t|jddkDrd| dd|jdf<|jjTr|jddk(rtWt)jX|jjT|z|jz D]j}d |dzzt| kDr?t-j.d||jjTfzdd|jd n| dd |zz  | dd |zz <lt|rot?jZ|| f} nWt]|} |t|k7r.tEjFdj_t|||t|ksJ|jdd kDrX|jdkrIt|r>|j`tbur,t-jddt|t| fz||| zz}tg|dt|D]5\}}|j|t|jhd|jh|<7d|_5| |_|xjt|z c_|dkDs|t|jlk\r&t|d gztod| fd gzz|_6|S#t$r' |j|d}n#t$rYnwxYwYwxYw)!aget new candidate solutions in genotyp. Solutions are sampled from a multi-variate normal distribution. Arguments are `number` number of returned solutions, by default the population size `popsize` (AKA lambda). `xmean` distribution mean `sigma_fac` multiplier for internal sample width (standard deviation) `ignore_integer_variables` allows to not change integer variables at all which is in particular useful when a (small) mutation is added to a given solution. `ask_geno` returns a list of N-dimensional candidate solutions in genotyp representation and is called by `ask`. Details: updates the sample distribution if needed and might change the geno-pheno transformation during this update. :See: `ask`, `ask_and_eval` Nrrconditioncov_alleviaterrIrrECMA_AIIFrr"z/ %d special injected samples with popsize %d, zpopsize %d will be usedz/ and the warning is suppressed in the followingr'rG!CMA_injections_threshold_keep_lena4Mean shift samples are expected but missing. This happens if, for example, `ask` is called more than once, without calling `tell` (because the first call removes the samples from the injection list). `cma.sigma_adaptation.CMAAdaptSigmaTPA` step-size adaptation generates mean shift samples and relies on them. Using ``ask(1)`` for any subsequent calls of `ask` works OK and TPA works if the first two samples from the first call are retained as first samples when calling `tell`. EXAMPLE: X = es.ask() X.append(es.ask(1)[0]) ... es.tell(X, ...)z@mean_shift_samples, but the first two solutions are not mirrors.rrrCMA_mirrormethodz?fewer mirrors generated than given in parameter setting (%d<%d))rFrrzC{0} injections were handled while only {1} sample(s) were asked forrz6 %d pre-injected solutions will be used (popsize=%d))rFindexcounterT)8rrr{rrzrynumber_of_injectionsr%alleviate_conditioning_in_coordinatesalleviate_conditioningrrKeyErrorrrraiirr:aryrvequals_approximatelyrrrmahalanobis_normr,_random_rescaling_factor_to_mahalanobis_sizerrV RuntimeErrorrrformat_warningrGr r|rfrrjsamplerkrrsroundvstackr rrr print_messagerrevaluations_per_f_valuer}r^)rArrrignore_integer_variables xmean_argrr:arinjr nominatormNiidrrrs r-rzCMAEvolutionStrategy.ask_geno0s> >VaZWW__F  ) )Q .D112D0012  % 99- .  6 6tyyAY7Z[\7] ^  ' ' 2J(KB(O P =IIE  U+F3 6yy#>>Q&$)!hhll6* DJJ&    %D DH A:9,0H0HTXT]T]0^~~!5569II##$U'*4+H+H'I4<<&X%Y&?3tGdGdCehiCi&j%k]a\j\jno\o'Xuw%yz //u:'1155a8((+dffckDIIFi>qADIIMQUQ[Q[[\..&&DNNQ,>#e*q.u:>&.,aDMMeTUhWZ^ZdZdddaRVVE!HaK0266%(A+3FFLL//a58)D,,0&(> NN ,A./-C8==3C  / /3u: = /NNQ&d.E.E::a? A@E " !8..2::dggnnT.B#CCC   )'C :M0N,ORS,S9:Atyy!4556wwDII.@$AQ$Fryy)9)9F)BT\\)QRSAAE{SX-++,m/0$''2B2B.C-D'13I6:nn56 8 '*2A:&6CQU OT5zii -,CU# 006s5z60JLSZ' '' IIi 1 $!);E   (88    X!$USX 6!7 8eck!c+3u:./DAq!^^t??@3D , ,Q /0()$ &&#c(2& A:3t'B'B#CC*-e*w*>4FB!FB#+#D ' c  //6v>E  s6^ ^6^#"^6# ^/,^6.^//^65^6c ||jz }t|rF|t|jddt |ddzdz|j |z z}||jz }|S)z5change `x` like for injection, all on genotypic levelrrrr"rG)rr~rrrrrArs r-random_rescale_to_mahalanobisz2CMAEvolutionStrategy.random_rescale_to_mahalanobissn  M q6 'TYYw'3q6215q893>AVAVWXAYY YA TYYr,cnt||jk7r#tdt||jfzt|s#t j dd|j ytj|jddt|dd zd z|j|z S) z``self.mean + self._random_rescaling_factor_to_mahalanobis_size(y) * y`` is guarantied to appear like from the sample distribution. zlen(y)=%d != %d=dimensionz,input was all-zeros, which is probably a bugrrrrrrr"rG) rrrr~rrrrrrr)rArs r-rzACMAEvolutionStrategy._random_rescaling_factor_to_mahalanobis_sizes q6TVV 8CFDFF;KKL L1v    NI*... :vv(dii(CF3A69:C?$BWBWXYBZZZr,c |j|d|jz }|s||j |z}|j|z }|jj||jj}|jj|||j|j||jj}|S#|jj||jj d|jz }YxYw)areturn ``_round_int_variables(pheno(self.mean - (geno(x) - self.mean)))`` and update `sent_solutions` and `_round_integer_variables.archive` archives. >>> import numpy as np, cma >>> es = cma.CMAEvolutionStrategy(np.random.randn(3), 1) #doctest: +ELLIPSIS (3_w,... >>> x = np.random.randn(3) >>> assert cma.utilities.math.Mh.vequals_approximately(es.mean - (x - es.mean), es.get_mirror(x, preserve_length=True)) >>> x = es.ask(1)[0] >>> vals = (es.get_mirror(x) - es.mean) / (x - es.mean) >>> assert cma.utilities.math.Mh.equals_approximately(sum(vals), len(vals) * vals[0]) TODO: this implementation is yet experimental. TODO: this implementation includes geno-pheno transformation, however in general GP-transformation should be separated from specific code. Selectively mirrored sampling improves to a moderate extend but overadditively with active CMA for quite understandable reasons. Optimal number of mirrors are suprisingly small: 1,2,3 for maxlam=7,13,20 where 3,6,10 are the respective maximal possible mirrors that must be clearly suboptimal. rITrrr)r)rrrErIrrPrrHrrRr_round_int_variablesrr)rArpreserve_lengthdxrs r- get_mirrorzCMAEvolutionStrategy.get_mirror s8 5$$Q'/$));B  $CCBG GB IIN GGMM!)>)>)E)EM F ""11"G  % %a1N1N1V1V % W 5aT-B-B-J-J#')+/995Bs CAD c |jj} | t|} |jddk(rUt j |jj | z|jjz } |j|_nd} | | dzksJtj| |_ |jd} g}|j| |||}| |j}g}| rt|dr |j}||g|}t|dr/|xj |jz |jz z c_| r8|jddkDr&|jdkrt#j$d d d |dkDr6|jdkr't#j$d d d nt'|dgz}t)| D]}|j+d|j+d}}d }| | ||s{| rt#j$dd d |dz }|r|jd||d}nZ|| | z k\rR|| | z k(r#tj,|d d | z d |_ |j/||j| dz |z }d}ddkr$|j0dz|j3||z z }| dk(r ||g|n||| |z||z zzg|}| ||rU|dkDrP||gt)t|dz Dcgc]%}| dk(r ||g|n||| |z||z zzg|'c}z}|dzdzdk(r$t#j$d||jfz|p| ||s{|j5||j5|t||_t9d|Drt)t'|Dcgc]!}||t#j:||r|#}}t#j$dt=|ddt'|dkDrdndzdt=|dd |j||fScc}wcc}w)a? sample `number` solutions and evaluate them on `func`. Each solution ``s`` is resampled until ``self.is_feasible(s, func(s)) is True``. Arguments --------- `func`: objective function, ``func(x)`` accepts a `numpy.ndarray` and returns a scalar ``if not parallel_mode``. Else returns a `list` of scalars from a `list` of `numpy.ndarray`. `args`: additional parameters for `func` `gradf`: gradient of objective function, ``g = gradf(x, *args)`` must satisfy ``len(g) == len(x)`` `number`: number of solutions to be sampled, by default population size ``popsize`` (AKA lambda) `xmean`: mean for sampling the solutions, by default ``self.mean``. `sigma_fac`: multiplier for sampling width, standard deviation, for example to get a small perturbation of solution `xmean` `evaluations`: number of evaluations for each sampled solution `aggregation`: function that aggregates `evaluations` values to as single value. `kappa`: multiplier used for the evaluation of the solutions, in that ``func(m + kappa*(x - m))`` is the f-value for ``x``. Return ------ ``(X, fit)``, where - `X`: list of solutions - `fit`: list of respective function values Details ------- While ``not self.is_feasible(x, func(x))`` new solutions are sampled. By default ``self.is_feasible == cma.feasible == lambda x, f: f not in (None, np.nan)``. The argument to `func` can be freely modified within `func`. Depending on the ``CMA_mirrors`` option, some solutions are not sampled independently but as mirrors of other bad solutions. This is a simple derandomization that can save 10-30% of the evaluations in particular with small populations, for example on the cigar function. Example ------- >>> import cma >>> x0, sigma0 = 8 * [10], 1 # 8-D >>> es = cma.CMAEvolutionStrategy(x0, sigma0) #doctest: +ELLIPSIS (5_w,... >>> while not es.stop(): ... X, fit = es.ask_and_eval(cma.ff.elli) # handles NaN with resampling ... es.tell(X, fit) # pass on fitness values ... es.disp(20) # print every 20-th iteration #doctest: +ELLIPSIS Iterat #Fevals... >>> print('terminated on ' + str(es.stop())) #doctest: +ELLIPSIS terminated on ... A single iteration step can be expressed in one line, such that an entire optimization after initialization becomes:: while not es.stop(): es.tell(*es.ask_and_eval(cma.ff.elli)) Nrrrr" is_feasible)rrr3rhz0selective mirrors will not work in parallel mode ask_and_evalrz6aggregating evaluations will not work in parallel moderzrejection sampling will not work in parallel mode unless the parallel_objective makes a distinction between called with a numpy array vs a list (of numpy arrays) as first argument.rrErGz= %d solutions rejected (f-value NaN or None) at iteration %dc3RK|]}|duxstj|!ywrWrr?rqfs r-rtz4CMAEvolutionStrategy.ask_and_eval..s%9SqDy+ELLO+S%'z f-values z...r'z contain None or NaN at indices ask_and_tell)rrrBrrrrr_mirrormethod1_donerarange mirrors_idxrrrorhrrrrrrargsortr1rrrr"r~r?r)rArr3rrrrrh aggregationkappa parallel_modernmirrorsr3rX_firstXevals0 fit_firstr{rr9rejectedlength_normalizer_irrs r-r4z!CMAEvolutionStrategy.ask_and_eval:sZ''//  &kG 99' (A -yy!1!1G!;dggoo!MNH'+~~D $H7a<'''99X.ii . ((7%u4(H =IIE  t]+))W,t,It]+4#3#3f#>A#5##L"$:<G v-IwA;;q>9==#3qAH);q!#4 ''<'(> @ A E95a8A'H,,Gh..+-::c?2b8mB;N+O($*:*:7Q;?*K(LMA%&!6)- d6K6KAPUI6V(V%',qjDNTN):!:a%i!HH  q!$q#QC5:3{Q;O5P+R5Pr?DqjDNTN,0AR9RVWZ_V_9`1`,hcg,h-i5P+R%RSAqLD(A-''(g#T^^4)56Q);q!#4T JJqM HHQK] ^(+;'7$ 9S9 9$SX?!1v~c!f)=D?   #&s3Bx=SX]EPR#S#&t9!.!/ 6 $  0 #v %+R?s *Q &QcL|js |jr tdg}|jr|j|j z g}|j |d |djJ |dddk(r=tj|ddk(r"tjddd|j|jd r)|j |jj!|j"j$r|jd d k(s:|jd dk(r`t'|d r|j(|jdz kr8t+|}||j-z }t/|t+||_||_|S#t$rY/wxYw) aLprovide genotypic directions for TPA and selective mirroring, with no specific length normalization, to be used in the coming iteration. Details: This method is called in the end of `tell`. The result is assigned to ``self.pop_injection_directions`` and used in `ask_geno`. zFound unused injected direction/solutions. This could be a bug in the calling order/logics or due to a too small popsize used in `ask()` or when only using `ask(1)` repeatedly. rrrgzzero mean shift encountered_prepare_injection_directionsrpc_line_samplesrr"r=)rzryrrVrmean_oldrbaserrrrrrrr`rrrror=rget_selective_mirrorsr_indices_of_selective_mirrors)rAri0s r-rMz2CMAEvolutionStrategy._prepare_injection_directionssu  ( (D,H,H)* *  " "99t}},-C JJAw A +++2wqzQ266#b'S.#9##$A>5t~~G 99& ' JJtww||~ & 77   ,-2II01Q6#D*?@004>>A3EESB 4--/ /C16r3s81DD .(+% !" '4 's!F F#"F#c||jj}t|dsg|_g}t d|dzD]}}d|j dvs'|j j| |jvs;|j|j|j|j j| z t||t|jz k\sJ|S)aget mirror genotypic directions from worst solutions. Details: To be called after the mean has been updated. Takes the last ``number=sp.lam_mirr`` entries in the ``self.pop[self.fit.idx]`` as solutions to be mirrored. Do not take a mirror if it is suspected to stem from a previous mirror in order to not go endlessly back and forth. rRrzall-selective-mirrorsr) rrrorRrrrrrrOrr)rArrrs r-rQz*CMAEvolutionStrategy.get_selective_mirrors s >WW%%Ft<=13D .q&1*%A&$))D/9TXX\\1"=MUYUwUw=w 4==488DHHLL!4D+EEF&3x6C(J(J$KKKKK r,c 4|jdrtj|s|S|d}|d}n|durd}|j|jj ztj |jjz}t|jj|D]p\}}||s|jdD]P}tj|||||zkDs%||xx|||ztj||z zcc<Rr|S)a6versatile: limit absolute values of int-coordinates in vector list `dX` relative to the current sample standard deviations and by default only when the respective recombination weight is negative. This function is currently not in effect (called with threshold=inf) and not guarantied to stay as is. ``dX == pop_sorted - mold`` where ``pop_sorted`` is a genotype. ``threshold=2.3`` by default. A 2.3-sigma threshold affects 2 x 1.1% of the unmodified (nonsorted) normal samples. rgffffff@c |dkSr=r+ws r-recombination_weight_conditionzZCMAEvolutionStrategy.limit_integer_relative_deltas..recombination_weight_condition> s 1u r,TcyNTr+rWs r-rYzZCMAEvolutionStrategy.limit_integer_relative_deltas..recombination_weight_conditionA sr,) rrrgr:rfrsqrtrjrvziprrXr)rAdX thresholdrYrkrXr0rs r-limit_integer_relative_deltasz2CMAEvolutionStrategy.limit_integer_relative_deltas( s"yy,-R[[5KI  I ) 1  +t 3 zzDNN222RWWTWW=N=N5OO"-EAr-a0#67Avvbe}y47'::1T!W!4rvvbe}!DD8.  r,c|j|s|r$|jj|g|i|S|jj|d|jjS)aIreturn integer-rounded phenotype depending on `round_integer_variables` module setting. Without further arguments, `self.gp.pheno` is called with ``copy=True, into_bounds=self.boundary_handler.repair`` as additional arguments, otherwise ``*args, **kwargs`` are passed to `self.gp.pheno`. Tr)r.rErHrr)rAsolutionr3r4s r-rz!CMAEvolutionStrategy.to_phenotypeL sq((/3v*7x)Q$)Q&)Q[ [)-xd<@>> import cma >>> func = cma.ff.sphere # choose objective function >>> funb = cma.BoundDomainTransform(func, [1, None]) # set bounds >>> def cons(x): # define constraints ... return [2 - x[0]] >>> consb = cma.BoundDomainTransform(cons, [1, None]) >>> es = cma.CMAEvolutionStrategy(np.random.rand(2) / 3, 1.5) # doctest:+ELLIPSIS (3_... >>> while not es.stop(): ... X = es.ask() ... es.tell2(X, [funb(x) for x in X], [consb(x) for x in X]) >>> assert all(funb.transform(es.best_feasible.x) >= [2 - 1e-5, 1 - 1e-5]) >>> assert all(funb.transform(es.best_feasible.x) <= [2 + 1e-5, 1 + 1e-5]) The value of `es.result.xbest` is not reliable with constraints, because a dynamic augmented Lagrangian is optimized. Instead, use `es.result.xfavorite` or `es.best_feasible.x`. :See: class `CMAEvolutionStrategy`, `ask`, `ask_and_eval`, `fmin` )constraints_values check_pointsr)tell2)rA solutionsfunction_valuesrirrhs r-tellzCMAEvolutionStrategy.tell s(Vzz)_-?'3#% %r,c B|jr tdtjDcic]\}}|dk7s ||c}}|_t |}|t |k7rt dt ||fz||jjzdkrt dt|zdzdztj|ds tj|ddrx|jd krVtjd t|dd tt|dd } | xrt!j"| |D cgc]} | d }} n t d  t'd|Drt)|D cgc] \} } |  |  } } } t)|D cgc] \} } |  tj*| s| "}} } tj,|D cgc]} | tj*| s| c} } tj.dt|dt| dt| dd|j|| zD]} | || < t1d|Dst)|D cgc]%\} } tj2t5| s| '}} } tj.dt|dt|D cgc]} ||  c} ddd|j|'|t |k7rt dt ||fz|j6|j8kst;|j<setj.d|j8|j6t |j>t |j@zfzdd|jd|_|xjd z c_ |xjB||jDzz c_!|jFjI||jJ||jB||jM|||}|jNjQ|tR|dv }d!dkr[|}|Dcgc]}|jTjW|| }}|jTjY||tR|jZ|dv"|j\}|j}d!dkrJ||j^k7r;tj.d#|jja|jb|d dkr||j^d$zkDs&||j^d$z ks||j^krN|d%krId&} tj.d'je| t ||j^| dd|j||jfjhkr/t d(je||jfjh|jbd)d*uxs|j|jbd)k}|sYtk|jltnjpr5tojr||_6|ju|jl|jw|dd$|d$d|jx}|jzjI||||jJ|j||_?tj|j~|z|_Atj|j|_Ct||_<|jjd|jxdt |jxd$z} t5t |jxd$zr|jx| n$|jx| d z |jx| zd$z |_|jd%zdk(rO|jjd|jxd|jjd|j,t |jd+kDr4|jj|jjt |jd,d-|z|j^z zkDr|jj|j|j,|_J|j|j,kDr|j,|_K|j,|jkrd|_Mn|xjd z c_M|j,|_Ld|_Ng}t)|D]\}}d dkrU||j|j||jzj|d.dgd/fvr |jnd|jJ0gz }|jJj|d}ts||jTj||||1|jJ|jTfD]C}|jttd$|j^zd2fd-|j^zfE||_I|jj||jd kDr|j|_Y|j|_X|j}|dd.dgd/fvr) t |r|}D]}|j||tj||j}|j|}d}|jbd3d4k(rt|d5s$tj.d6dd|jn|jxd|jkDr|jj}|j|tj|gt|z}d }tj$d7|j|jxdfzdd|j|jbd89n|jbd3r|jFj|jxdkr|jFj|jFjg}nh|j|jt|jFjd*:|jzjd.:g}tj.d;d|j|dtj|dgt|z}d }||_N|j|d|jfjh|jtj|jfj|d|jfjh|_Z|jd k7rD|xj|jzc_Z|xjd |jz |zz c_Zd!dkr|jbd<r|r|jjtd |jbd<|zd=zd$z|jjfjd=z|jjz |j|j|z zz z }n|jj}d!dkr,|xjt;|jd$zgz c_nd!dkr|xj|jjfjd=zt;d>|jz tj|jj|j|z zd$zd=zz|jz |d=zz |z gz c_n|j}|jbd?|jbd@z|jlj|jfj|jfjAjWdB|jz} |jbd?|jbdCz|jljjWdD|jz}!|r$|j|j|j}!} }|jj|}"d!dkr|jd k(r tdEtr'|"s%|jj|jd!dkr#|"s!tt|jdFztjsd }"|jd k(r tdG| d d |"d$zz |zd$|z zz z}#d |z |jz|"|d$|z z|jjfjzd=z|jz |z z|j|z z|jjz z|_|jbdHr,|jlj |j|_|jj|jjfj|jbd@|jbdCI}$|$dJ}%d |%z |jz|"|%d$|%z z|jjfjzd=z|jz |z z|j|z zz|_ |j|j||z tjtj}&|#|!zdkDr|jgt |&}'|#g|'D(cgc]}(|!|(z c}(z})|$dBg|'D(cgc] }(|$dD|(z c}(z}*t |&t |jfkDr|#g|jfD(cgc]}(|!|(z c}(z}+|+dd |jfjhzt |&t |jfz dgzz|+d |jfjhzdz}+|)|+k(sJdK|jbd<vr8tj|)})|)|)dkDxxd |jbd<dKzzcc<t |)t |&d zk(sJ|D]O} | d |zz } |)| dkr|)| xx|jbdLzcc<|*| dks6|*| xx|jbdLzcc<Q|r|jjI|jlj |jgt|jlj |&|j|jjzz ztjd$tj|)z|jbdMNn&|&|j|jjzz },|jbdOrt|jldPr|*D(cgc]<}(|jbd?|jbdOz|jljz |(z>}-}(|jjI|jlj |j|jjz g|,D.cgc]}.|jlj |. c}.z|-|jbdMNd!dkr(|&|j|jjzz },|j}/tj r{ |j\d=ztj"j%|jj&z }0|0|jlj)|jj&z}/|jljI| |#dQzz d=z|/zgt|,z|)t'tj|jlj*dkr,tdRt|jlj*z|ju|jl|j|_ |xj|jj/||Szc_r|jbdTr|jxj|jbdTk\rt|dUs d-dgz|_|j|jxj|j,|jf|j2|jt |j2z<|j,|_r|j5d!dkrt'|j|jjz|j6d=zztj|jbdVkrttj|jbdV|j|j6d=zzz |_rt1|j|jz|j6d=zzdWtj|jbdVzk\sJt'|j|jjz|j6d=zztj|jbdXkDrOttj|jbdX|j|j6d=zzz |_r|jt|jz|jbdYkr3t5|jbdYt|jz |_rt8d kDr|jt8|j:zkDr t5|jt|jlj*d=zz }1|1d kDrq |xjl|1zc_6|xj|1d=zzc_r|xj,|1d=zzc_|jbdZxx|1d=zzcc<|jutj>rtAtj>rW|xjtj>|jtj>|jz zc_Znz|xjtjBt;tjD|jt;tjD|jz zc_Zd!dkrtk|jztFry|jzjI|jsSt|jzj|jzjK|jd.[d.[d.:|_ZtLr|jO|_|jbd8d\kDr}|jdkrntk|jtPsSt |j>r>tj$d]t |j>|jd$k(rd^nd_fzd|_g|_I|j|jTdd|jVjY|jbd`jI|jd*|_ |jZj]|jjad!dkr6|jja|jb|jbd?dbyycc}}wcc} w#tj$d|zddd|jxYwcc} } wcc} } wcc} wcc} } wcc} wcc}w#t$rt|j^}YHwxYw#t$rY 2wxYwcc}(wcc}(wcc}(wcc}(wcc}.w#xYw#t0tf$r!|jjI||SYwxYw#t<$rYwxYw#t<$rY+wxYw#t$r@t!j"da|jztj^|_YwxYw)cz see `tell`z4tell can currently only be called once per iterationrAz)#f-values = %d must equal #solutions = %drEzpopulation size z is too small with option zCMA_mirrors * popsize < 0.5rrz[function_values is not a list of scalars, the first element equals z with non-scalar type zq. Using now ``[v[0] for v in function_values]`` instead (further warnings are suppressed)z3objective function values must be a list of scalarszfunction values=%srmr ) method_name class_namerrFc3RK|]}|duxstj|!ywrWr7r8s r-rtz-CMAEvolutionStrategy.tell2.. s%E_qDy+ELLO+_r:Nzfunction values with index /z2 are nan/None and will be set to the median value rc3XK|]"}tjt|$ywrW)rrgr)rqvals r-rtz-CMAEvolutionStrategy.tell2.. sFos2;;uSz*os(*z are not finite but .z3#constraints_values = %d must equal #solutions = %dzno independent samples generated because the number of injected solutions, %d, equals the number of solutions asked, %d, where %d solutions remain to be injected r)rF)revert_modifiedr r)rwrr z3population size has changed, recomputing parametersr"rz/The number of solutions passed to `tell` shouldz{0} generally be the same as (or close to) the population size, was: len(solutions)={1} != {2}=popsize. To suppress this warning execute warnings.filterwarnings('ignore', message='{3}.*') zLnot enough solutions passed to function tell (passed solutions={0} < mu={1})rTg@rDr;Fr+)rrr)rPrJr5 CMA_elitistinitialf0zHSet attribute `es.f0` to make initial elitism available or use cma.fmin.zinitial solution injected %f<%frrrzgenotype for elitist not foundrrGrr CMA_rankonerr CMA_rankmurzparameters modifiedz : hsig-stallzhsig=1CSA_invariant_path) c1_factor cmu_factorcc inc_cmu_posCMA_active_injectedr)integer_indicesr beta_diagonal_accelerationrz{A sampler variance has become negative after the update, this must be considered as a bug. Variances `self.sm.variances`=%s)rl+stall_sigma_change_on_divergence_iterations(_stall_sigma_change_on_divergence_eventsrgv?rmindx tolupsigma)copy_if_changedrz* %d directions prepared for injection %sz (no more messages will be shown)r'tolxstagnationzCMAEvolutionStrategy.tell(countiter=%d): "timer" attribute not found, probably because `ask` was never called. Timing is likely to work only until `tell` is called (again), because `tic` will never be called again afterwards.)ccovfacr)rrrwitems _tell2_argsrrrrrrrhrrrrrGr r!r~rr?rrrrgrr{rrr}rzryrr"rrr_constraints_handlingrunrounded_population&round_integer_variables_revert_changesrrNcatch_and_truncater.rrsetrrrXrrrjrrirprk_record_rankingsrrrErrrr@rsortedrrRrrrrrrr pop_sortedrIrPrepair_genotyperr^rsr^rcheck_consistencyrO mean_old_oldrrr!_clean_injected_solutions_archiverorzrRrr+rr9x_genor rrYrpositive_weightscmeanrrrrxrrr:rrqrrrrcc_seprmrnhsigr _record_hsigrrr_hsigr`rfrtransform_inverse_path_for_invariant_updateraisotropic_mean_shiftrr`r integer_active_limit_std3integer_active_limit_recombination_weight_conditionlogr _ps_for_pclinalgnormps transformrv _sigma_oldupdate2rrrurw_redistribute_sigma_abover9r_stationary_spherer/r\squarerrJr_new_injectionsrMrr|rQr set_paramsrpauserr)2rArkrlrhrirr{r|rr'rurr9idx_noneidx_nanr solutions_rrr flg_diagonalrrs_genoarcmoldinjected_solutions_indicesprepended_solutionsx_elitxprrrrrc1a dd_paramscc2pop_zero_weightsrXsampler_weightssampler_weights_dd_sampler_weightspop_zero_encodedwszr`facalphas2 r-rjzCMAEvolutionStrategy.tell2 sH   UV V.4X^^-=M-=TQfAqD-=M)n #o& &H #O 4c:;< < !! !A %/#c(:9::;< <{{?1-. ;;q1!45~~*!0003?13E/FDQ`abQcLdHe2g"$%#9q)99H&I#s1vO&I$%Z[['J E_E E&/&@N&@daAI&@HN%.%?e%?TQ1=UZUaUabcUdq%?Ge oEomELLOoEFA   #&w<XA!HIN 6 Hx'%&"(FoFF!*?!;1!;A++eAh/!;C1   #&s8Sc1Rc/!2Dc1R-S!UV[ 6 H  )cS9K5L.LR #$6 7=>? ?  ) )T-F-F F334   !00554889C@\@\<]]_!_ 2DNN  D*+& ! 3!=!=== ,,ot P  )"88(:IGO11FFy,R!-Z!?GA  6"J9BCA))!Q/IC LL + +Iz,R+/+D+D!-Z!? , A FF WW 6cRZZ'    U V GGKK 3 ' q5cBJJN*cBJJN.B "** qAA   !%&,VAs9~rzz1%M &(>  P  @$fS"**--8: :yy0D8F..DIIn,EE  477G4Q4Q R..q1DG   ) obq1?123FGhhIT**11/4HTXTgTgimipipq ::cjj1OC**S--.) 3771:& LA SWW)93771:!$1 !:a ?A ^^a A % LL  3771: . NN ! !!SZZ 0 s|| s " LL    NN   sxx=2Q 33 3 HHLLN ;; **CK >>CJJ & ZZCN ::,, ,#$C  A % !jj i(DAq1u Q(,(=(=(E(E =IQVXY[]_aPb>A  $ D   }} eQB7 7 (|$&C$$SV,jjocgg&%)%K%KC%P"  99] #y 04&##12DNNDdgg%*226:jj&DI!56&'###$E%)WWcggaj$9%:%'=$(NNDIIiBJJMM2DII>FF2::66NRZZ]]8KL 88q= II !I II!bhh,$. .I 6diio,GGMMCTYYt_q-@3,F,J&&+dggmm;%%dii$&678,9%::EGGMME 6   3tyy!|#4"5 5  6   477??#8#8##=b466kRVVDFFHHdii$6F%GG!KLcQ$Rzz$"$%sF$+-2$3#4 4  UU YYx 499]#; ;dgg>P>P**"" (:(:?Q?<P>P>R>V>VW\^`^d^d>ee ))RYY CB $$T* 6~~"+,  $$T^^4 6c$..)N:;D~~"h AT1W*a"f556r6TWW$t1r6]TWW__%:%::S@4::M (!$(II$4(68<8N8N(OO 99) *.2gg.G.G.PD +NN--dggoo.C.C26))M2J3799\3J.* oGtxx'$AG_tww'<'<T>T3TUVCSTCSaTWW66q9CSTU(, 2E(F *H 6'/4::@V@V3V'W$WW((""ffckBIINN4;K;K;N;N,OO"DGG$5$5 ,,//%11sU{!3c 9B >?"#34 5-/2::dgg//0145"$FHKDGGL]L]H^$_`` TWW%** K JJ$**2248G3I IJ 99B C))TYY7d-ee4!KL@BdV = 9 94??DJJ\X  9 9NNS)V)V%WW YDJ   64:: 6 66#E 499X#6789 DIIh,?!@%)^^dggsl%B"DE 4::6#E2::dii.A#BBCDDDTZZ$.."8"88477C<G 499X#6789 DIIh,?!@!%$''3,!>"@A ::DFF #dii&8 8tyy1CK?@DJ $q ( 6DD /djj3tww/@/@+A3+FFG19/5( eSj0 5#:5 ,/5#:=/,,.  ( ( 556 j;;DMMJ(;;DIIFGH  RWWS4==)A%B%(499)=%>&?@@ 6j!6!6G--::499Ed33;;%%,,TYY,N$)<+168DI ,0,N,N,PD ) )$q(T^^a-?t//1ABD112##$P%()F)F%G%)^^q%8&H>@%B%BC34D /"&))Q   ++DII6F,GHOOPTPYPYZ  / JJ      " 6 GGKK 499X+>K J _N&'J ##$8?$J06CY,-INeE12SPDr (BJJ' (P   'B6J,IB^U""E $^4 K    # #D/ # J K\%   f / MMQ!NN + , ,,.DJ  /s< A~<A~<BA A#A A4A42 A:=A:A:- B@ *B@ B@ 2#B@! B@L B@:M5 BA NBAO BAX!ABAZ>#BA ]A:BA$b1BA*o#9BB0p"BB} BCA*A1@B@7@6B@7@: BAABAA$BA'A*.BBBBBB BB-B,BB-B0 BB>B=BB>CABD D BD c ||!t|dstjd| t|dstj|}nMtjt ||Dcgc]"\}}|t |j|z$c}}}|d|jjjDcgc].}|jjj||||0}}|jturtj }d} ntj"}d} |D cgc]P} |j$j'|| | |j(j*|j,|j.R} } |j| |j0tj2|jjj4| } |jj6dk7rB| |jj6z} | d|jj6z |j0zz } | Scc}}wcc}wcc} w)areturn an updated mean based on the input arguments, namely, the solutions `X` and the ranking implied by `F` and `G`. `G` is only used if the constraints handling is active. Elements of `X` are transformed to the genotype as by default, with repair and with accessing the sent solutions archive. This method is meant to give a headsup _before_ to call `tell` of what the updated mean will be and can be useful, for example, for constraints surrogates. Naugmented_lagrangianzget_new_mean: was called with constraints values G, however `self` has no attribute `augmented_lagrangian` to process them. G is hence ignored.TF)rrrrr)rorGr rr@r]rrrrXrrrrNrYr5rr rErIrrPrrrrrr) rArFFGrr9graarrrrs r- get_new_meanz!CMAEvolutionStrategy.get_new_mean s =/E!F MMD E 9GD*@A**Q-C**,/1I7,5&1a #d&?&?&B"CC,578C -477??--. 0. * * 2 2 6 6qtQqT B.  0  ! !U *BDBD   1 ww||BqE!%(,(=(=(E(E#'#7#7$($7$7 9   sDII.vvdggoo66< 77==A  DGGMM !D Q&$))3 3D ;7  0s&'H. :3H4*AH9cy)zRdo nothing by default, otherwise assign to `_record_rankings_` after instantiationNr+)rAvalsrls r-rz%CMAEvolutionStrategy._record_rankings sr,ct|}tj|t|jjz}tj|t|z}|dd|ddg|_|jS)zcompute ranks of `vals` in `function_values` and in `self.fit.fit` and store the results in `_recorded_rankings`. The ranking differences between two solutions appear to be similar in the current and last iteration. Nr")rrranksr_recorded_rankings)rArrlr0r1s r-_record_rankings_z&CMAEvolutionStrategy._record_rankings_" sjDz [[TXX\\ 22 3 [[_ 55 6#%bq62bq6"2&&&r,c@|D]}|t||jk7rtdd|jzztj|t }|r|j j|r|jj||jz y)a inject list of one or several genotypic solution(s). This is the preferable way to pass outside proposal solutions into `CMAEvolutionStrategy`. Passing (bad) solutions directly via `tell` is likely to fail when ``CMA_active is True`` as by default. Unless ``force is True``, the `solutions` are used as direction relative to the distribution mean to compute a new candidate solution returned in method `ask_geno` which in turn is used in method `ask`. Even when ``force is True``, the update in `tell` takes later care of possibly trimming the update vector. `inject` is to be called before `ask` or after `tell` and can be called repeatedly. >>> import cma >>> es = cma.CMAEvolutionStrategy(4 * [1], 2) #doctest: +ELLIPSIS (4_w,... >>> while not es.stop(): ... es.inject([4 * [0.0]]) ... X = es.ask() ... if es.countiter == 0: ... assert X[0][0] == X[0][1] # injected sol. is on the diagonal ... es.tell(X, [cma.ff.sphere(x) for x in X]) Details: injected solutions are not used in the "active" update which would decrease variance in the covariance matrix in this direction. Nz%method `inject` needs a list or arrayz" each el with dimension (`len`) %dr) rrrrrrryrrzr)rArkforcerbs r-injectzCMAEvolutionStrategy.inject/ s<"H8}& !H;dffD"FGGzz(%8H,,33H=--44X 5IJ"r,c|g}t|D]U\}} |jj|}t|jt r |ddkDsE|j |Wt|jjD]\}}|d|jdz kst|dr|jjrHt|jt r|ddkDr&tjdt!|zt"|jj||S#t$rY,wxYw)zreturn indices of `pop` which are in ``self._injected_solutions_archive`` and were "externally" injected (non-TPA). Remove old entries from ``self._injected_solutions_archive`` and warn in case. rrrFr"integer_mutationsaorphanated injected solution %s This could be a bug in the calling order/logics or due to a too small popsize used in `ask()` or when only using `ask(1)` repeatedly. Please check carefully. In case this is desired, the warning can be surpressed with ``warnings.simplefilter("ignore", cma.evolution_strategy.InjectionWarning)`` )rrrrrrrrrrrroris_nonerGr rr%)rArindicesrrrr{s r-rz6CMAEvolutionStrategy._clean_injected_solutions_archiveY s'cNDAq &4488; "$"2"24DE7VWNN1%#99??ABDAq~ 22&9:--55&t'7'79IJW:> ' #&a& ') +; <0044Q7#C$/  sD.. D;:D;c |jD]\}}||jvrV|jddkDr4dt|vr%tjdj ||||j|<jtjdj |||j j|j|jd|jj|S)aclear termination and set any `CMAOptions` passed via keyword arguments or like ``**opts_dict``. The validity of the option names is checked, the validity of the values is not checked. Some resettings will not be effective. For those with a ``'#v'`` flag in their description, the effectiveness is guarantied. See `CMAOptions`. Return `self`, the new options are in ``self.opts``. rrz#vzO{0} is not a versatile option, resetting to {1} may not have the desired effectznoption {0} is not recognized (hence value {1} is ignored) Check out `cma.CMAOptions` to see the valid names.r)r) rrrrGr rrrrlclear)rAr4r{r|s r- reset_optionsz"CMAEvolutionStrategy.reset_options sLLNDAqDII~99Y'!+JLO0KMM#EEKVAq\S  !  U%va|-#  DIItyy': ;  r,c|j|jjz|jjt j |jjzzS)zreturn array of coordinate-wise standard deviations (phenotypic). Takes into account geno-phenotype transformation, step-size, diagonal decoding, and the covariance matrix. Only the latter three apply to `self.mean`. ) r:rEscalesrfrrr\rjrvrs r-rkzCMAEvolutionStrategy.stds sIdggnn,''"''$''2C2C*DDF Gr,c|j|jjtj|j j zzS)areturn array of coordinate-wise standard deviations (genotypic). Takes into account step-size, diagonal decoding, and the covariance matrix but not the geno-phenotype transformation. Only the former three apply to `self.mean`. )r:rfrrr\rjrvrs r- _stds_genozCMAEvolutionStrategy._stds_geno s5zzT^^33bggdgg>O>O6PPQQr,c|jS)a-return a `CMAEvolutionStrategyResult2` class instance. :See: `cma.evolution_strategy.CMAEvolutionStrategyResult2` or try ``help(...result)`` on the ``result`` property of an `CMAEvolutionStrategy` instance or an `CMAEvolutionStrategyResult2` instance. )_result2rs r-resultzCMAEvolutionStrategy.result s}}r,c |jj\}}}t||||j|j|j |j dd|jj|j|jS)a8return a `CMAEvolutionStrategyResult` `namedtuple`. :See: `cma.evolution_strategy.CMAEvolutionStrategyResult` or try ``help(...result)`` on the ``result`` property of an `CMAEvolutionStrategy` instance or on the `CMAEvolutionStrategyResult` instance itself. Nr) rrNrdrrrrrrrkrl)rArr9evalss r-_result0zCMAEvolutionStrategy._result0 stiimmo 1e)  OO NN   diil8M8M8T8T  U II IIK  r,c Xfd}jj\}}}|||d|d}t||||jjj j jddjjjj S)a;return a `CMAEvolutionStrategyResult2` class instance. :See: `cma.evolution_strategy.CMAEvolutionStrategyResult2` or try ``help(..._result2)`` on the ``result2`` property of an `CMAEvolutionStrategy` instance or on the `CMAEvolutionStrategyResult2` instance itself. ctdr.td}dDcgc]}t||dc}\}}}}d}ttjfdDScc}w)z~assumes that `.best_feasible` is a BestFeasibleSolution. Otherwise we get more `None` value entries. ru)rr9rcountNc34K|]}|dvr ||fyw))rr9rrfeasible_iterationsNr+)rqr{ds r-rtzGCMAEvolutionStrategy._result2..get_best_feas.. s)%U1 $SS'(1Ys)rogetattrrwr DictClass2) rr9rrrrfieldrrAs @r- get_best_feasz4CMAEvolutionStrategy._result2..get_best_feas s t_-t_5)A0C)A18eT0J)A0C,1a,A##%U%UV V 0CsA%Nr) rrNrnrrrErHrrrrkrl)rArrr9r best_feass` r-rzCMAEvolutionStrategy._result2 s Viimmo 1e!!QeT: *   OO NN GGMM$))A,D4I4I4P4PM Q II IIK  r,c z||jj}tdj|j |rdj|nd|dkDrdj||dkDrdndndtd |jj j||j |jjfz|jd krtd d jt|j|j|jj jj!d dj!ddztdd jt|j"jj!d dj!ddz|j$Stdt|j|j|jj ddddztdt|j"ddddz|j$S)zEpretty print result. Returns `result` of ``self``. Nztermination on {0}{1}{2}z ({0})r'rz after {0} restart{1}rrz6final/bestever f-value = %e %e after %d/%d evaluationsrozincumbent solution: rrrz[,[zstd deviations: zincumbent solution: %s ...]rrzstd deviations: %s ...])rr9rrrllastrrrrrrrrrsplitreplacerkr)rAnumber_of_restartstime_str fbestevers r- result_prettyz"CMAEvolutionStrategy.result_pretty s   I (// /7(//(+R*A-*00*3E3ICrS35 7 8 F IINN  i$))//JKK L 66A: (388C8I8I$))aeavava}a}8I8~45F5F5H,I,3GC,>wwtS?QR S $sxxDII0D0D0F'G,3GC,>wwtS?QR S {{ /3t7H7H`d`u`u`|`|7H7}A@A8B4CDGEG4HI J +s499Ra=/A#2/FG H{{r,c|jdkDr.tjdj|jt |dr.tjdj|j t j|j|_tt|j _ |jddkrd|j _ tj|_d|_d|_t"rug|_t j&t j(t j&t j*t j&t j,g|_yy) z>A  MMN' ) 4/ 0 MMB#VD$=$=> @$8$L$LTVV$T! , 80QD % % - 99Y " $05D % % -446 $!% $!#D (DDEYEdEde(DDEYEdEde(DDEYElElm"D  %r,c &|St|ds|j|jj||Dcgc]}|j|}}t |Dcgc]\}}|t |z}}}t j|} |jj| || |Dcgc]}|j|}}|Dcgc] }t |} }tt| k(s J| ft | Dcgc] \}}||z }}}t|D cgc]\} } td| Dr| } } } | rntfd| D|_ |j|j|_| D]3} |jj| || || || d|| i5t rd}n|jGt"t j$t j&| zt%dt%fz}nE|jt|z }| s+|t jt j&| z }t(rt|dru|j*rit |||D]X\}}}}t-j.|jj0||||}|j*D]}|j|||Zt s|j2t4kr8|j,|Dcgc] }t7t d|D|z"c}S|Dcgc]}t7||zc}Scc}wcc}}wcc}wcc}wcc}}wcc} } wcc}wcc}w) areturn "fake" `function_values` when `constraints_values` are given and update the augmented Lagrangian coefficients before. `solutions` are passed only to record the best feasible solution. The returned fitness values are the augmented Lagrangians with an offset such that the value is never below the function value of the last seen feasible solution (best per iteration). If no feasible solution was seen yet, add `initial_infeasibility_foffset` and the current maximal penalty as offsets. Use also module settings `tell_find_feasible_first` and `tell_find_feasible_only`. rc3&K|] }|dk yw)rNr+)rqvis r-rtz=CMAEvolutionStrategy._constraints_handling..T s"7Qr27Qsc3(K|] }| ywrWr+)rqrrls r-rtz=CMAEvolutionStrategy._constraints_handling..W s'UDTq(:DTs al_penaltiesinforr c32K|]}|dkDs |dzywrr"Nr+rqgis r-rtz=CMAEvolutionStrategy._constraints_handling..~ s:a26b!ea  )rorrset_coefficientsr]rrargminrrrrrsr r rutell_find_feasible_only"tell_initial_infeasibility_foffsetr^rr r rconstraints_info_dict count_callsrtell_find_feasible_firstr)rArlrhrkrrr9r al_valuesiminal_penalty_sumsrr|feasible_indicesf_offsetrfvalgvalsalvalsrr)rus ` r-rz*CMAEvolutionStrategy._constraints_handling/ s  %" "t34  . . 0 !!22 / 1?QQ>P11!4>P Q.1/<.PQ.PFQQQZ.P Qyy# !!(()>);D)A C>PQ>P11!4>P Q+78)>&%""))'*,>q,A'G!'Kq&PQTUUVVr,c|js#tjddd|jyt j |j j d|dzg\}}||k(r|xj|zc_yy)aincrease `sigma` by `sigma_fac` in case of a plateau. A plateau is assumed to be present if the best sample and ``popsize * sample_fraction``-th best sample have the same fitness. Example: >>> import cma >>> def f(X): ... return (len(X) - 1) * [1] + [2] >>> es = cma.CMAEvolutionStrategy(4 * [0], 5, {'verbose':-9, 'tolflatfitness':1e4}) >>> while not es.stop(): ... X = es.ask() ... es.tell(X, f(X)) ... es.manage_plateaus() >>> if es.sigma < 1.5**es.countiter: print((es.sigma, 1.5**es.countiter, es.stop())) zYInbetween `ask` and `tell` plateaus cannot be managed, because `sigma` should not change.manage_plateausrNrr*)rrrrrprctilerr:)rArsample_fractionrzfms r-r7z$CMAEvolutionStrategy.manage_plateaus sr(    !>,.D $ 0 DHHLL1o.C*DEB 8 JJ) #J r,c |jjS#t$r1t|jt |jz dzcYSt $r1t|jt |jz dzcYSwxYw)zcondition number of the statistical-model sampler. Details: neither encoding/decoding from `sigma_vec`-scaling nor `gp`-transformation are taken into account for this computation. r")rjcondition_numberrr^rxrsrrs r-r<z%CMAEvolutionStrategy.condition_number sn 277++ + 2K#dff+-1 1# 2K#dff+-1 1 2s7B 6B  B cz|rWtj|rBtj|jtj|jz |kryt |drTt |jtjr.tj|jtj|jz }|jj}|jj}|xj|zc_ |xj|zc_ |j|jtj d|tj|jtj|jz ||jjfz|j"yyy)zpass scaling from `C` to `sigma_vec`. As a result, `C` is a correlation matrix, i.e., all diagonal entries of `C` are `1`. Nrjze condition in coordinate system exceeded %.1e, rescaled to %.1e, condition changed from %.1e to %.1er)rrgr^rwrsrorrjrrpr<to_correlation_matrixrfr`rkrr!r)rA conditionold_coordinate_condition old_conditionfactorss r-rz:CMAEvolutionStrategy.alleviate_conditioning_in_coordinates s. Y!766$''?RVVDGG_4y@  4 :dggw7O7O#P')vvdgg'H $ GG44Mgg335G NNg %N GGw G   )   !H0266$''?1R$dgg&>&>@!@ #nn  .$Q r,cVtj|jj|SrW)rrrE _tf_matrixr*s r-_tfpzCMAEvolutionStrategy._tfp$svvdgg((!,,r,cVtj|jj|SrW)rrrE_tf_matrix_invr*s r-_tfgzCMAEvolutionStrategy._tfg&svvdgg,,a00r,c|jjr|r|j|kryt|jdr%t j ddd|jdy |j}|jj}|jjd }tj||j|_ tj||j|jz |_|j!|j|j!|j|j|j$zj$|j_||jz |j_t+j,|jj.d z|_|j0|j_|j4|j_d |j_|j8|j:usJ|jj7|j8|_t=|j>D]-\}}|jj7||j>|</t=|j@D]-\}}|jj7||j@|</|jj7|j:|_t j d||jfzdd|jy#t"$rt j d d YywxYw)a9pass conditioning of `C` to linear transformation in `self.gp`. Argument `condition` defines the limit condition number above which the action is taken. >>> import cma >>> for dd in [0, 1]: ... es = cma.CMA(2 * [1], 0.1, {'CMA_diagonal_decoding' : dd, 'verbose':-9}) ... es = es.optimize(cma.ff.elli, iterations=4) ... es.alleviate_conditioning(1.01) # check that alleviation_conditioning "works" ... assert all(es.sigma_vec.scaling == [1, 1]), es.sigma_vec.scaling ... assert es.sm.condition_number <= 1.01, es.sm.C Details: the action applies only if `self.gp.isidentity`. Then, the covariance matrix `C` is set (back) to identity and a respective linear transformation is "added" to `self.gp`. Nrz %.1e, injected solutions become "invalid" in this iteration)!rErFr<rrrrrrj to_linear_transformation_inverseto_linear_transformationrrr`rarfrkrrrDrGr rerrErOrHrNrrOrryrz)rAr?old_condition_numbertf_invtfrrs r-rz+CMAEvolutionStrategy.alleviate_conditioning)s&ww!!d6K6Ki6W  tyy,- .    J(*@ ,  #'#8#8 WW==?F111=BffVTWW-DGvvfdhh&?@DH   ) TWW%#nnrtt366!'$..!8(99$..:P:PRS:ST 99))"yy ---GGOODII. d::;DAq.2ggooa.@D ( ( +<d;;| |j}t|tjrFt d|_|j dz|_t d|_|j|_ yt|tjtjfr|j |_ y|jj|_ |jj |_|jj|_|j%t!j"|j|_ yy#t$rd|jB|jd|j\|_|_|xjdzc_nddkrd|_d|_YwxYw)zhelper function for a smooth transition to sampling classes. By now all tests run through without this method in effect. Gradient injection and noeffectaxis however rely on the non-documented attributes B and D in the sampler. NrrGrrrE)rjrrrir rrvrxrrw_rgsGaussVDSamplerGaussVkDSamplercovariance_matrixrrrdiag)rAsm_s r-rkz$CMAEvolutionStrategy._updateBDfromSMws1 ;''C c788 91XDF]]C'DF1XDFffDG d1143G3GH ImmDGWW..DF "vv!''$&&/"" "66%%ATYY/@%A$&&%INDFDFFFsNF!V!DF!DF  "s6D//A*FFcH|jdkDrtjdt|t|k7r;t dt t|zdzt t|zdz|j j}t||zdk7r/t dt t|zdzt |ztt||zD]<}|j|j|||z|dz|z|||z|dz|z>y) aResume a run using the solution history. CAVEAT: this hasn't been thoroughly tested or in intensive use. Given all "previous" candidate solutions and their respective function values, the state of a `CMAEvolutionStrategy` object can be reconstructed from this history. This is the purpose of function `feed_for_resume`. Arguments --------- `X`: (all) solution points in chronological order, phenotypic representation. The number of points must be a multiple of popsize. `function_values`: respective objective function values Details ------- `feed_for_resume` can be called repeatedly with only parts of the history. The part must have the length of a multiple of the population size. `feed_for_resume` feeds the history in popsize-chunks into `tell`. The state of the random number generator might not be reconstructed, but this would be only relevant for the future. Example ------- :: import cma # prepare (x0, sigma0) = ... # initial values from previous trial X = ... # list of generated solutions from a previous trial f = ... # respective list of f-values # resume es = cma.CMAEvolutionStrategy(x0, sigma0) es.feed_for_resume(X, f) # continue with func as objective function while not es.stop(): X = es.ask() es.tell(X, [func(x) for x in X]) Credits to Dirk Bueche and Fabrice Marchal for the feeding idea. :See also: class `CMAEvolutionStrategy` for a simple dump/load to resume. rz8feed should generally be used with a new object instanceznumber of solutions z and number function values z must not differz( must be a multiple of popsize (lambda) rN) rrrrrrrrrrrm)rArFrlrrs r-feed_for_resumez$CMAEvolutionStrategy.feed_for_resumes"n >>A     Z [ q6S) )3c#a&kA./C()*,>?@ @''// FW  "3c#a&kA>?L!" "s1v()A HHJ IIaG QUg$56%a'k1q5G2CD F *r,cv |jj |jj|jj k(r|j |jyy#t$r|jjdYqwxYw#t$r|j |jYywxYw)zcall sm.update_now like sm.sample would do. This avoids a bias when using `_random_rescaling_factor_to_mahalanobis_size` which was visible with TPA line samples. rN)rjrrr last_update count_tellrkrs r-_try_update_sm_nowz'CMAEvolutionStrategy._try_update_sm_nows  GG    *ww""dgg&8&88$$TWW-9  GGNN1    *   ) *s#A'AB'$B B$B87B8c|jt|jjt j ||j jz |jz S)aQreturn Mahalanobis norm based on the current sample distribution. The norm is based on Covariance matrix ``C`` times ``sigma**2``, and includes ``sigma_vec``. The expected Mahalanobis distance to the sample mean is about ``sqrt(dimension)``. Argument -------- `dx`, a *genotype* difference to the distribution mean. As `dx` is interpreted as a difference to the mean, the return value does not depend on the current mean. Example ------- >>> import cma, numpy >>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1) #doctest: +ELLIPSIS (5_w,... >>> xx = numpy.random.randn(2, 10) >>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1])) `d` is the distance "in" the true sample distribution, sampled points have a typical distance of ``sqrt(2*es.N)``, where ``es.N`` is the dimension, and an expected distance of close to ``sqrt(N)`` to the sample mean. In the example, `d` is the Euclidean distance, because C = I and sigma = 1. ) r\rrjrrrrfrr:)rAr0s r-rz%CMAEvolutionStrategy.mahalanobis_normsH: !TWW\\"**R.4>>3I3I"IJTZZWXXr,c|j|jk7r|jj|j|j z |j jz |_|xj|jjjdz|jz |jjz zc_|j|_|jS)anormalized last mean shift, under random selection N(0,I) distributed. Caveat: while it is finite and close to sqrt(n) under random selection, the length of the normalized mean shift under *systematic* selection (e.g. on a linear function) tends to infinity for mueff -> infty. Hence it must be used with great care for large mueff. rG)r\rrjrrrOrfr_isotropic_mean_shiftrrXrr:rrs r-rz)CMAEvolutionStrategy.isotropic_mean_shifts  / /4>> A)-)B)BYY.$..2H2HH*JD &  & &477??+@+@#+E +R-1WW]],; < &37>>D 0 )))r,cVtdtjjy)z#print annotation line for `disp` ()zGIterat #Fevals function value axis ratio sigma min&max std t[m:s]N)rsysstdoutflushrs r-disp_annotationz$CMAEvolutionStrategy.disp_annotation0s WX r,c2|jd}fd}|rjdz d|zzdkr|sjtdsd_d_jdkDrj sRjdksCj|zdks1jjjz j kDr?jj_xj dz c_jdrJjj}tt|d zd zd |d zzjdd z}nd }tdjtjjdtjjddt!j"j"zdjdrjjdkDr5j$j'j$j!z n0t'j(dzt!j(dzz zdj*zdj*t!j(j,dzzzzdj*t'j(j,dzzzz|f|rdndt.j0j3S)zprint current state variables in a single-line. Prints only if ``iteration_counter % modulo == 0``. Overwrites the line after iteration `overwrite`. :See also: `disp_annotation`. rc&jjdtd}n}j xr|dkDxrj|kDS)Nverb_disp_overwriterr)rrNrrlr)iters overwriterAs r- do_overwritez/CMAEvolutionStrategy.disp..do_overwrite@sL  &;U5\J!yy{?KuqyKT^^e5K Kr,rrDtimes_displayedrr verb_time<:z%2.1f0r'rrr#z%.15ez%4.1erz%6.2ez%6.0erG  )end)rrrdrotime_last_displayedrkrlrelapsedrrBrjustrrrrrsrrxr^rfr:rwrarbrc)rAr$rirjtocstimes` ` r-dispzCMAEvolutionStrategy.disp5s >YY{+F L "rF{3a7 $$&4!23+,('($~~!tyy{dnnq6H!%&!81! '3txx||+< = '26))N2Kt~~`d`i`ijx`yOy,066::<$&&**,+F03DNN14D0EDNN[\L\H]0]!_!($** 4 '4::DNNTWWVY\ R!#9 ; sAB:>9B:)Tr+FN)NN)FT)NNrNr+)NNrFrWTN)NFN)NNF)rNN)g?rG)gחA)gmB)9r'r(r)r*rrrlr?r4rurrrrr+rr1rrr4rMrQr`rr.rmrjrrrrrrrkrrrrrrrr2rr7r<rrErHrrkrXr\rrrdrxrzr+r,r-rrsn^ HM0dV>p 5n'HR#J<67]D+/7<EN [*^')TYZ!" RWl\&P0;?EI"H [$N=A,0N%b"&ZKxLLEM0d] '(KT$L4GGRR  ,# # J<@ $!F2j V#J@$< 2 2.2-1L\*BHF\*"Y@**0 2fr,rcFeZdZdZddZd dZdZedZedZ y) rafProvide a termination signal depending on how much a vector has changed, typically applied to the distribution mean over several iterations. The `stop` property is the boolean termination signal, the `update` method needs to be called in each iteration with the (changing) vector. ``self.stop is True`` iff - ``delta t > threshold`` and - ``Delta x < delta * max(1, sqrt(delta t / threshold))`` for at least delta t iterations. The (iteration) threshold is computed in property `time_threshold` based on the iteration count and three parameters as ``p1 + p2 * count**p3``. Nctjd}|d|_|d|_|d|_d|_d|_d|_||_y)zR`x` is the initial vector (optional), default settings are taken from `CMAOptions`rrrr"N) rr2deltatime_delta_offsettime_delta_fractime_delta_exporcount_xr)rArrs r-r?z_StopTolXStagnation.__init__sU|  !12!W !%a#Aw   r,c|dvr|S|dur d|_|St|t||D](\}}t ||sJ||t |||*|S#t$r ||_|cYSwxYw)a`param_values` is a `list` conforming to ``CMAOptions['tolxstagnation']``. Do nothing if ``param_values in (None, True)``, set ``delta = -1`` if ``param_values is False``. `None` entries in `param_values` don't change the respective parameter and ``[0.12]`` is the same as ``[0.12, None, None, None]``. Details: In principle, `'delta'` should be propto sqrt(mu/dimension). r[Fr)riterrr]rorz)rA param_valuesrrrrPs r-rz_StopTolXStagnation.set_paramss < 'K 5 DJK , ul3KD%4& , ,& dE*4  %DJK s AA-,A-c|xjdz c_|jtd|j|jz |jz fdzz}|dks7|j +t j|j |z dzdz|kDr+t j||_|j|_|S)z$caveat: this stores x as a referencerrGrr") rrr^rtime_thresholdrrrr)rArrs r-rz_StopTolXStagnation.updates a  S!djj4<<&?4CVCV%V!WXZ]]] 19"&&$&&1*q*A3*F*NZZ]DF::DL r,ch|j|j|j|jzzzSrW)rrrrrs r-rz"_StopTolXStagnation.time_thresholds4&&$$tzz43G3G'GGH Ir,cN|j|jz |jkDSrW)rrrrs r-rlz_StopTolXStagnation.stops zzDLL(4+>+>>>r,rW))rrrr) r'r(r)r*r?rrrrrlr+r,r-rrys@ 4 II??r,rcBeZdZdZiffd ZddZdZddZdZxZ S) rakeep and update a termination condition dictionary. The dictionary is "usually" empty and returned by `CMAEvolutionStrategy.stop()`. The class methods entirely depend on `CMAEvolutionStrategy` class attributes. Details ------- This class is not relevant for the end-user and could be a nested class, but nested classes cannot be serialized. Example ------- >>> import cma >>> es = cma.CMAEvolutionStrategy(4 * [1], 1, {'verbose':-9}) #doctest: +ELLIPSIS >>> print(es.stop()) {} >>> es.optimize(cma.ff.sphere, verb_disp=0) #doctest: +ELLIPSIS <... >>> es.stop()['tolfun'] == 1e-11 True :See: `OOOptimizer.stop()`, `CMAEvolutionStrategy.stop()` ct|t}tt||rin|g|_d|_d|_d|_ |j |_ |j |_|r|j|yy#Y+xYw#Y xYwr=) rrr>rr?stoplistrrr_update)rArrrBs r-r?z_CMAStopDict.__init__sA34 lD*2Q?    JJDM JJDM  LLO      sA>B>BB cb|s|S||j td|j||S)zAupdate and return the termination conditions dictionary z4termination conditions need an optimizer to act upon)rrr)rArrs r-rz_CMAStopDict.__call__s6K :$''/ST T R r,c&| |j}|J|jdk(r3|jrtjd|j |Sddkr,|j|j k(r ||jk(r|S |j|_||_|jxs|j|j}|j}||_ |ddk\r|dr tjj|jdrt|dd 5}|j}ddd tt!j"j%}t'|D]O}||j)vst+j,d |d |jdd |j/|Q|j1||D]}|j3|||d  |j9d|j:j<|dk|j9d|j>dz |dk\|j9d|jd|dzk\|j@|jBjDtGjH|jJzz}|j9dtM||jN|jPz|dzkD|j9dtS||dkxr?tS|j@|jBjD|jTzz|dk|jr tW|ndtW|jXjXt[|jXjXz } tW|jXj\t[|jXj\z } |j9d| |dkxr| |dk|j9d| |d|jXj^|jXj`z zk|jr| nd|j9dtc|jXj\dkDxr| |dk|drtWd|dzdz dz tc|jXjddz f} ddkrtg|j|d|j|d d!|jhz zzkDtc|jXjdd!kDtGjj|jXjld| tGjj|jXjl| d| zk\tGjj|jXjdd| tGjj|jXjd| d| zk\f| |jkrto| } |j9dddkxrx|dxrp|j|d d!|jhz zzkDxrK|j>|j:jpz |jhz |jddz kDxrtc|jXjdd!kDxrd| ztc|jXjdkxrtGjj|jXjld| tGjj|jXjl| d| zk\xr\tGjj|jXjdd| tGjj|jXjd| d| zk\|j9d"|jrjttw|j@|jxjWz }|j9d#|d#xr||jN|d#zkD|jr|nd |j9d$|jzj||d$kD|jr|jzj|ndddkrd ztc|jXjdkrtGjj|jXjld|  tGjj|jXjl| d| zztGjj|jXjdd|  tGjj|jXjd| d| zzf} |xj| D cgc]} | dkrd| zn| dzc} z c_@ddkr|j|jd%|zzk(jd}|j9d&tM||Dcgc] }to|c}|d'd(ur |j|d'kDr|jdzdk(r|j|z} |j9d)tS|j|jd*|j@z|jjx|z|jBjDztc|jjjdkDr|jjdd|fn|jjdzzk(|j9d+|d+xr(|jxd,|d+d-z|jxdzkD|d+|j9d.tM|j|jddks tc|r9ddkrl|jXjXd|jXjXtod/tc|jXjXzkrd|jX_Gn|jXxjdz c_G|jXj|d0kDr|j9d0ddkrtW|jXjXt[|jXjXcxk(r#|j:jj<k(rJnnGt+j,d1|jXjXd|j@fz|j2ddkr|j9d3tc|jXj\dkDxrtW|jXj\t[|jXj\k(xr?tW|jXjXt[|jXjXk(d4|j@zddkr6|d5d6k(r.|j9d7t|jdz|dk|S#Y xYw#1swY xYw#t4$r6tjddt7|jddY _wxYw#t~$r|jdkr YwxYwcc} wcc}w#t~$rYwxYw)8z9Test termination criteria and update dictionary Nrz0Cannot get stop value before the first iterationrrErisignals_filenamerz( unkown or non-versatile option 'z' found in file z>. Check out the #v annotation in ``cma.CMAOptions()``.)rdimzLSyntaxError when parsing the following expression with `ast.literal_eval`: z (contents of file r+ftarget maxfevalsrmaxiterr tolfacupxtolxtolfun tolfunrel tolfunhistro tolstagnationg@r"rDrr*rrtimeoutg? noeffectcoordrT noeffectaxisg?tolconditioncovrrGcallbackg?tolflatfitnesszflat fitness (f=%f, sigma=%.2e). For small sigma, this could indicate numerical convergence. Otherwise, please (re)consider how to compute the fitness more elaborately.rz flat fitnesszVplease (re)consider how to compute the fitness more elaborately if sigma=%.2e is largeriAz||xmean||^2P4Q-STc #  ACIIc1#56 iggii4 ?2 4 kmma'4 +<< > illcDO&;; = &(XX1E1EPRPUPU1V%W" k4))bmm3d;6GGHI J f4tF|CDT"((bll&:&:RUU&BCd6lRS9=c45d T !$BFFJJ#bffjj/ A!$RVV[[!1C 4D!D h+d8n<>,tH~= ? k+d;.?266>>TVTZTZTeTeCe.ff/3+D J l"&&++&*B,tL/AA C  cD11B6:C(>(C(CD "((RTTXXZ' ( lD$6%9"))d<&888??a 6  MM)((**T)_<.2oo"((**4 I 6a!ec"&&//22IIbff//344ryyARARSTUVYZUZA[7\\YYrvvr233biiPQRSVWRW@X6YY[C   c Jc1q5"a%a!e";c J J  q577bgg.H(HHHQQSTUVC MM/3s8c5Jcc!fc5J K ^$D0R\\DDX5X!a'LL1$MM."%bgg3>%'UUWWQZ<024,,2F2F 2Czx x;yyy65y6 zzc||jk(r||_d|_y|r?|jj|||n|jj |d||<yyrW)rrrrrrN)rArOcondrus r-rz_CMAStopDict._addstopsX $// !DK"DO  MM  %"!%sD!9 Ir,cTt|D]}|j|g|_y)zempty the stopdictN)rrr)rAr{s r-rz_CMAStopDict.clears"dA HHQK r,r[r}) r'r(r)r*r?rrrrrSrTs@r-rrs(2$ yv:r,rc  tj| fdfd}td||f| d||\}} |_ jj t j jj|fS)aminimize `objective_function` with lq-CMA-ES. See ``help(cma.fmin)`` for the input parameter descriptions where `parallel_objective` is not available and noise-related options may fail. Returns the tuple ``xbest, es`` similar to `fmin2`, however `xbest` takes into account only some of the recent history and not all evaluations. `es.result` is partly based on surrogate f-values and may hence be confusing. In particular, `es.best` contains the solution with the best _surrogate_ value (which is usually of little interest). See `fmin_lq_surr2` for a fix. As in general, `es.result.xfavorite` is considered the best available estimate of the optimal solution. Example code ------------ >>> import cma >>> x, es = cma.fmin_lq_surr(cma.ff.rosen, 2 * [0], 0.1, ... {'verbose':-9, # verbosity for doctesting ... 'ftarget':1e-2, 'seed':11}) >>> assert 'ftarget' in es.stop(), (es.stop(), es.result_pretty()) >>> assert es.result.evaluations < 90, es.result.evaluations # can be 137 depending on seed Details ------- lq-CMA-ES builds a linear or quadratic (global) model as a surrogate to try to circumvent evaluations of the objective function, see link below. This function calls `fmin2` with a surrogate as ``parallel_objective`` argument. The model is kept the same for each restart. Use `fmin_lq_surr2` if this is not desirable. ``kwargs['callback']`` is modified by appending a callable that injects ``model.xopt``. This can be prevented by passing `callback=False` or adding `False` as an element of the callback list (see also `cma.fmin`). ``parallel_objective`` is assigned to a surrogate model instance of ``cma.fitness_models.SurrogatePopulation``. `es.countevals` is updated from the `evaluations` attribute of the constructed surrogate to count only "true" evaluations. See https://cma-es.github.io/lq-cma for references and details about the algorithm. cR|jjjgyrW)rmodelxopt)r surrogates r- inject_xoptz!fmin_lq_surr..inject_xopts 9??''()r,ct|jdd}|durg|d<|S|vr|j||d<|S)z*append `inject_xopt` to kwargs['callback']rNF)r1rNr)r4cbrs r-callback_in_kwargsz(fmin_lq_surr..callback_in_kwargssU vzz*d; < ;!#F:   " IIk "!#F:  r,N)rparallel_objective) _fitness_modelsSurrogatePopulationfmin2rrrFrrr) r0r5r9rr4r_rrrs @@r- fmin_lq_surrrsb 334FGI* $F 0G  0&v. 0EArBL ??  RYYy'8'89 :B >>r,r"c |i}tj} tj|}t d|dzD]q} | dk(s|st j |} | dkDr(t jj|zdz|d<t|||}  | _ | dkDr3| j| _ | j| _d| j_| j#s$| j%}| |}| j'||| j| _t)| j*j,| j*j.D])\}}||r| j1t3||+|r&| j5| j6j8g| r#t;| r | | n| D] }||  | jj=| j?| j#s$| j@ddkDrB| jC| tEjFtEjH| jJ| j|d k\s>d | j#d vs*d | j#d vsd | j#d vsrn tMjN j*j,}| j*j,| jPjR_%| j*j.|| jPjR_*| jJ jP_%| jT| jP_*| j^ja| jT| jP_1| jd| jP_| j| jP_3| | _4| jT| fS#tV$r+}tYjZt]|dzYd}~d}~wwxYw#d| jP_1YxYw)aminimize `objective_function` with lq-CMA-ES. `x0` is the initial solution or can be a callable that returns an initial solution (different for each restarted run). See ``cma.fmin`` for further input documentations and ``cma.CMAOptions()`` for the available options. `inject` determines whether the best solution of the model is reinjected in each iteration. By default, a new surrogate model is used after each restart (``keep_model=False``) and the population size is multiplied by a factor of two (``incpopsize=2``) like in IPOP-CMA-ES (see also ``help(cma.fmin)``). Returns the tuple ``xbest, es`` like `fmin2`. As in general, `es.result.xfavorite` (and `es.mean` as genotype) is considered the best available estimate of the optimal solution. Example code ------------ >>> import cma >>> x, es = cma.fmin_lq_surr2(cma.ff.rosen, 2 * [0], 0.1, ... {'verbose':-9, # verbosity for doctesting ... 'ftarget':1e-2, 'seed':3}) >>> assert 'ftarget' in es.stop(), (es.stop(), es.result_pretty()) >>> assert es.result.evaluations < 90, es.result.evaluations # can be >130? depending on seed >>> assert es.countiter < 60, es.countiter Details ------- lq-CMA-ES builds a linear or quadratic (global) model as a surrogate to circumvent evaluations of the objective function, see link below. This code uses the ask-and-tell interface to CMA-ES via the class `CMAEvolutionStrategy` to the `options` `dict` is passed. To pass additional arguments to the objective function use `functools.partial`. `not_evaluated` must return `True` if a value indicates (by convention of `cma.fitness_models.SurrogatePopulation.EvaluationManager.fvalues`) a missing "true" evaluation of the `objective_function`. See https://cma-es.github.io/lq-cma for references and details about the algorithm. Nr maxrestartsrrGrTrrrFrrzN Valid assignment of `es.best.last` (best of last/current iteration) failed.)5r BestSolution2r amend_restarts_parameterrrrrBrrrrrrhrrrrlrrmr]rfvaluesrFr_ifloatrrrr/addrxrrrr localtimer9r nanargminrrrrrGr rrErNr count_savedcomparedbest_fmin_lq_surr2)r0r5r9rrr incpopsize keep_model not_evaluatedrrirunrrrFrr9rr0rrs r- fmin_lq_surr2rs;d   D!::8DHa(=112 19J';; 0`` or ``restarts['maxrestarts'] > 0`` and if ``current_evals < min((restarts['maxfevals'], options['maxfevals']))`` and neither the ``'ftarget'`` nor the ``termination_callback`` option was triggered; ``restarts['maxfevals']`` does not terminate *during* the run or restart; to restart from different points (recommended), pass ``x0`` as a `callable`; see also parameter ``bipop``. ``restart_from_best=False`` which point to restart from ``incpopsize=2`` multiplier for increasing the population size ``popsize`` before each restart ``parallel_objective`` an objective function that accepts a list of `numpy.ndarray` as input and returns a `list`, which is mostly used instead of `objective_function`, but for the initial (also initial elitist) and the final evaluations unless ``not callable(objective_function)``. If ``parallel_objective`` is given, the ``objective_function`` (first argument) may be ``None``. ``eval_initial_x=None`` evaluate initial solution, for ``None`` only with elitist option ``noise_handler=None`` must be `True` or a `cma.NoiseHandler` class or instance to invoke noise handling. The latter gives control over the specific settings for the noise handling, see ``help(cma.NoiseHandler)``. ``noise_change_sigma_exponent=1`` exponent for the sigma increment provided by the noise handler for additional noise treatment. 0 means no sigma change. ``noise_evaluations_as_kappa=0`` instead of applying reevaluations, the "number of evaluations" is (ab)used as scaling factor kappa (experimental). ``bipop=False`` if ``bool(bipop) is True``, run as BIPOP-CMA-ES; BIPOP is a special restart strategy switching between two population sizings - small (relative to the large population size and with varying initial sigma, the first run is accounted on the "small" budget) and large (progressively increased as in IPOP). This makes the algorithm potentially solve both, functions with many regularly or irregularly arranged local optima (the latter by frequently restarting with small populations). Small populations are (re-)started as long as the cumulated budget_small is smaller than `bipop` x max(1, budget_large). For the `bipop` parameter to actually conduct restarts also with the larger population size, select a non-zero number of (IPOP) restarts; the recommended setting is ``restarts <= 9`` and `x0` passed as a `callable` that generates randomized initial solutions. Small-population restarts do not count into the total restart count. ``callback=None`` `callable` or list of callables called at the end of each iteration with the current `CMAEvolutionStrategy` instance as argument. ``init_callback=None`` `callable` or list of callables called at the end of initialization of the `CMAEvolutionStrategy` instance with this instance as argument (like `callback`). This allows to reassign attributes without a corresponding `CMAOption`. For example, ``es.integer_centering = lambda *args: None`` disables integer centering (which is enabled by default when ``integer_variables`` are given in the `options`) or ``es.integer_centering = cma.integer_centering.IntCentering(es, correct_bias=False)`` disables its bias correction. ``constraints`` A function that takes a solution `x` as input and returns a list of constraint values desired to become <= 0. Optional Arguments ================== All values in the `options` dictionary are evaluated if they are of type `str`, besides `verb_filenameprefix`, see class `CMAOptions` for details. The full list is available by calling ``cma.CMAOptions()``. >>> import cma >>> cma.CMAOptions() #doctest: +ELLIPSIS {... Subsets of options can be displayed, for example like ``cma.CMAOptions('tol')``, or ``cma.CMAOptions('bound')``, see also class `CMAOptions`. Details ======= This function is an interface to the class `CMAEvolutionStrategy`. The latter class should be used when full control over the iteration loop of the optimizer is desired. Examples ======== The following example calls `fmin2` optimizing the Rosenbrock function in 10-D with initial solution 0.1 and initial step-size 0.5. The options are specified for the usage with the `doctest` module. >>> import cma >>> # cma.CMAOptions() # returns all possible options >>> options = {'CMA_diagonal':100, 'seed':1234, 'verb_time':0} >>> >>> x, es = cma.fmin2(cma.ff.rosen, [0.1] * 10, 0.3, options) #doctest: +ELLIPSIS (5_w,10)-aCMA-ES (mu_w=3.2,w_1=45%) in dimension 10 (seed=1234...) Covariance matrix is diagonal for 100 iterations (1/ccov=26... Iterat #Fevals function value axis ratio sigma ... 1 10 ... termination on {'tolfun': 1e-11} ... final/bestever f-value = ... >>> assert es.result.fbest < 1e-12 # f-value of best found solution >>> assert es.result.evaluations < 8000 # evaluations The above call is pretty much equivalent with the slightly more verbose call:: es = cma.CMAEvolutionStrategy([0.1] * 10, 0.3, options=options).optimize(cma.ff.rosen) x = es.result.xbest where `optimize` returns the `CMAEvolutionStrategy` instance. The following example calls `fmin2` optimizing the Rastrigin function in 3-D with random initial solution in [-2,2], initial step-size 0.5 and the BIPOP restart strategy (that progressively increases population). The options are specified for the usage with the `doctest` module. >>> import cma >>> # cma.CMAOptions() # returns all possible options >>> options = {'seed':12345, 'verb_time':0, 'ftarget': 1e-8} >>> >>> x, es = cma.fmin2(cma.ff.rastrigin, lambda : 2. * np.random.rand(3) - 1, 0.5, ... options, restarts=9, bipop=True) #doctest: +ELLIPSIS (3_w,7)-aCMA-ES (mu_w=2.3,w_1=58%) in dimension 3 (seed=12345... In either case, the method:: cma.plot(); (based on `matplotlib.pyplot`) produces a plot of the run and, if necessary:: cma.s.figshow() shows the plot in a window. Finally:: cma.s.figsave('myfirstrun') # figsave from matplotlib.pyplot will save the figure in a png. The figure data can be saved like:: es.logger.zip() We can use the gradient like >>> 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 (5_w,... >>> assert cma.ff.rosen(es.result.xbest) < 1e-8 >>> assert es.result.evals_best < 3600 # 1% are > 3300 >>> assert es.result.evaluations < 3600 # 1% are > 3300 If solutions can only be comparatively ranked, either use `CMAEvolutionStrategy` directly via `ask` and `tell` or a "parallel" objective function accepting a list of solutions as input which returns, for example, the solution ranks: >>> def parallel_sphere(X): return [cma.ff.sphere(x) for x in X] >>> x, es = cma.fmin2(None, 3 * [0], 0.1, {'verbose': -9}, ... parallel_objective=parallel_sphere) >>> assert es.result.fbest < 1e-9 :See also: `CMAEvolutionStrategy`, `OOOptimizer.optimize`, `plot`, `CMAOptions`, `scipy.optimize.fmin` ) constraintsrr)fmin)r0r5r9rr3rrrestart_from_bestreval_initial_xr noise_handlernoise_change_sigma_exponentnoise_kappa_exponentbipopr init_callbackrrs r-rrrsWN !2v         $      "C q63r7?r,c .ddk rZfd}|ddd}|ddd}|d d d}|dd d} |d d d} |ddd } |ddd} |ddd.|ddd} |ddd}|ddd}|ddd}|ddd}|dd d}|s .s tStj}|d!=|d"=|d#=|d=|d=|t}tj |t|jj }t |}d}g}g}d}d}d}d}tj}gtdd d}|s|dkDr|d||z z}||z|d%<n|dk(rd&}nt||tdt|fzkrd&}ddkr| dz } |dz }d'tjjz}|d||z z}t||tjjd zzz|d%<t!|d(t|z|d%z |d)<nd*}|d||z z}||z|d%<||d)<t#|st#.r.fd+}|dk(rt%|t&r|} | j(d"}tj*|r*tj,|r|dkDrt/|| _t/| j(d#}|turtt3d,|Dr$t5j6d-j9|| j:j=|n!|rB|d d.k7r:|d r5t?j@d/|d01t'|jB||z|} nt'|||z|} t#|r| s#| j:d2d3k(s| j:d2r| | jE| jFd$| jHjJ| jL4}!tO||!g|| _(| jRjU|!g| jL| jPgd| xjVdz c_+|| _,.| _-| j:}tdNi|j}"|"D]&}#|"j]|#| j^|d%d5d6(tajb|"d |"d <|d7xs| jddkDxs|dkD| jf_4| jf}$ |$jjjUd8|jliddkrw| jddk(rX| j:d9dkDrF| j:d7s7tq| j:d:js| }$|$ju| jw| rgt%| txr| | j^}%n&| d$ur tjz| j^}%n| }%d$}&|"ddkDr6t|| j:d;<n"tjz| j^d}%d}&|%| _?t |D]}'|'duxs|'| ddkrn| js]| j.xs||||%jtj.<\}(})ddkr|d=rdtjjzdk\r]d|d=| j0dzztjj| j^zz|(d<tO||(dg||)d<| j:d0d kDrl| jdd ks,t!|)| jRjjkrd}*n.*dz }*|*d kDr$t?jd>|*z| jd?jd@d+| j|(|)|(D!cgc] }!d@|!c}!n| j|(|)|&r| xj0|%|(|)|| j|A|"dzzc_| xjV|%jz c_+|%j|%jkDr%| jji|%jddkr| jxjt/tj| tj|%jzzc_Q| jjdkDrdB| j_Q|D]}'|'duxs|'| | j|$ju| jr|$jrdndC|d9rH|dDrC| jdt|dD|d9zdk(s| jr|$jdE| js]|dFrt#|r| jE| jFd$| jHjJ| jL4}+tO||+g|},| xjVdz c_+| jRjU|+g| jL|,g| jVn|dFrt5j6dG|jU| jR| jL| jV|z }-| jV}|dk(r |d%}|d)}|r(d&k(r|ji|-n|ji|-|dHrB| j|tjtj|j|dz }tjit| jdI||z |"d dJkDsO| jV|"d dKk\s:dL| jvs(dK| jdIvsd| jdIvrn>| jV|d7<|"d| jjz|d%< |dMxxdz cc< |r| jRjU|| j| j| |$fzSt#tn$rYBwxYwcc}!w#t$rYewxYw)OaDEPRECATED: use `fmin2` instead. `fmin` will remain fully functional and be maintained in the foreseeable future. Return ====== Return the list provided in `CMAEvolutionStrategy.result` appended with termination conditions, an `OOOptimizer` and a `BaseDataLogger`:: res = es.result + (es.stop(), es, logger) where - ``res[0]`` (``xbest``) -- best evaluated solution - ``res[1]`` (``fbest``) -- respective function value - ``res[2]`` (``evals_best``) -- respective number of function evaluations - ``res[3]`` (``evaluations``) -- number of overall conducted objective function evaluations - ``res[4]`` (``iterations``) -- number of overall conducted iterations - ``res[5]`` (``xfavorite``) -- mean of the final sample distribution - ``res[6]`` (``stds``) -- effective stds of the final sample distribution - ``res[-3]`` (``stop``) -- termination condition(s) in a dictionary - ``res[-2]`` (``es``) -- class `CMAEvolutionStrategy` instance - ``res[-1]`` (``logger``) -- class `CMADataLogger` instance == es.logger The successor `fmin2` is an alias for:: res = fmin(...) return res[0], res[-2] For descriptions of the input arguments see `fmin2`. For completness, recovering the output of `fmin` from `fmin2`:: es = fmin2(...)[1] # fmin2(...)[0] is es.result.xbest return es.result + (es.stop(), es, es.logger) The best found solution is equally available under:: fmin(...)[0] fmin2(...)[0] fmin2(...)[1].result[0] fmin2(...)[1].result.xbest fmin2(...)[1].best.x The incumbent, current estimate for the optimum is available under:: fmin(...)[5] fmin2(...)[1].result[5] fmin2(...)[1].result.xfavorite Examples ======== The following example calls `fmin` optimizing the Rosenbrock function in 10-D with initial solution 0.1 and initial step-size 0.5. The options are specified for the usage with the `doctest` module. >>> import cma >>> # cma.CMAOptions() # returns all possible options >>> options = {'CMA_diagonal':100, 'seed':1234, 'verb_time':0} >>> >>> res = cma.fmin(cma.ff.rosen, [0.1] * 10, 0.3, options) #doctest: +ELLIPSIS (5_w,10)-aCMA-ES (mu_w=3.2,w_1=45%) in dimension 10 (seed=1234...) Covariance matrix is diagonal for 100 iterations (1/ccov=26... Iterat #Fevals function value axis ratio sigma ... 1 10 ... termination on {'tolfun': 1e-11} ... final/bestever f-value = ... >>> assert res[1] < 1e-12 # f-value of best found solution >>> assert res[2] < 8000 # evaluations The above call is pretty much equivalent with the slightly more verbose call:: res = cma.CMAEvolutionStrategy([0.1] * 10, 0.3, options=options).optimize(cma.ff.rosen).result where `optimize` returns a `CMAEvolutionStrategy` instance. The following example calls `fmin` optimizing the Rastrigin function in 3-D with random initial solution in [-2,2], initial step-size 0.5 and the BIPOP restart strategy (that progressively increases population). The options are specified for the usage with the `doctest` module. >>> import cma >>> # cma.CMAOptions() # returns all possible options >>> options = {'seed':12345, 'verb_time':0, 'ftarget': 1e-8} >>> >>> res = cma.fmin(cma.ff.rastrigin, lambda : 2. * np.random.rand(3) - 1, 0.5, ... options, restarts=9, bipop=True) #doctest: +ELLIPSIS (3_w,7)-aCMA-ES (mu_w=2.3,w_1=58%) in dimension 3 (seed=12345... In either case, the method:: cma.plot(); (based on `matplotlib.pyplot`) produces a plot of the run and, if necessary:: cma.s.figshow() shows the plot in a window. Finally:: cma.s.figsave('myfirstrun') # figsave from matplotlib.pyplot will save the figure in a png. We can use the gradient like >>> 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 (5_w,... >>> assert cma.ff.rosen(res[0]) < 1e-8 >>> assert res[2] < 3600 # 1% are > 3300 >>> assert res[3] < 3600 # 1% are > 3300 If solution can only be comparatively ranked, either use `CMAEvolutionStrategy` directly or the objective accepts a list of solutions as input: >>> def parallel_sphere(X): return [cma.ff.sphere(x) for x in X] >>> x, es = cma.fmin2(None, 3 * [0], 0.1, {'verbose': -9}, ... parallel_objective=parallel_sphere) >>> assert es.result[1] < 1e-9 :See also: `CMAEvolutionStrategy`, `OOOptimizer.optimize`, `plot`, `CMAOptions`, `scipy.optimize.fmin` rrEct|kDr+|vr"tdj||||S|vr|S|S)z4check posargs and kwargs for i and key, respectivelyz{0} given as positional and keyword argument with values {1} and {2}. Only either positional or keyword is allowed, see also `cma.fmin2`.)rrr)rrOdefaultr4posargss r-rzfmin.._get_valuesa7|a&=$`WQZ=??qz!f}c{"Nr,rrNr3r+r"rrrrFrrr#rrrrrrorrDrrr r rr0r5r9Trsmallg{Gz?rGrlargec|gg|dS)z*created from `parallel_objective` argumentrr+)rr3rs r-r0z fmin..objective_functionss-qc9D9!<.s813q6Q;szOptions must have explicit ("process") values in this usecase. The passed options are likely to lead to an error later. Passed options={0}Falsez+CAVE: restart_from_best is often not usefulrrrxry)rrr)rr)loc correct_keyr variable_annotationsrr"r)rrhrArCrz6%d f-degrading iterations (set verbose<=4 to suppress)rr)r3r)r$riDeval_final_meanaThe final mean was not evaluated (probably due to a parallel evaluation setup). Consider checking out ``es.result.xfavorite`` which is likely to be better than ``es.result.xbest`` (on the sphere function with >= 90% for dimension >= 10 or population size >= 2e3/dimension**3)rrrrrr) unchecked)arrwrrcheck_attributesr1r1rr all_stoppingsrr^rr@uniformrBrsr/rrr/rhrgrr:rrGr rrrrrrrrrrrrrzrrrr0rr2rr rrrrpersistent_communication_dictrrrrr writeOutputr NoiseHandlerrrrlr4rhrrrr9r!rNrjrmrevaluations_just_donemaxevalsminevalsrrrrr4rrxr$rzrrrrrvrrrKeyboardInterrupt)/r0r5r9rr4rrr3rrrrrrrrrrr fmin_optionsrruns_with_smallsmall_ilarge_ipopsize0maxiter0 base_evalsrr sigma_factorpopsize_multiplierpoptyperr fmin_optsr{r noisehandlerrr9rFrdegrading_iterations_count mean_phenofmean this_evalsrs/ `` @r-rrs F 1u Q 40!VR(1gt,aQ/&q*=uE<3 #A'7?'+?F"1ot< &04QST&U#)".DaH2w.b*d3"2= !*<< x}} - .    "  #  ?)G %%g.',,.)446$X.   aL!8)5l)Cd_F\)]&&.1C&CDO "WQG ,=(> >>!6MH1$#RYY%6%6%88 %1,%?$BX%Y""%h1CbiiFWFWFY[\F\1]&]"^Y"%hc'l0BT)_0T"UY "%1,%?$BX%Y""*-?"?Y"*Y./H=O4P= qyZ,@A\\$';;v&2;;v+>6A:$V}BHr||H56"55888 88>wIGGKK(\*=>'I!-.A!B''(U04YA-dfflV6KTRB-b,2GNB./&77=1Y>GGM2$2$:d464G4G4N4N020A0A(CA$$6q$@4$@ABEGGNNA3(9(9$&EE7A/MMQ&M$6B !$6B !77D"F,2C2C2EFIqBDD26y/'C+02 %7$O$Oj)%+Ij ! $M2RbllQ6FR$QR(BII YYF 44;;+&;;=> Av<<1$)>/I9:66!;69A= % 3 34l6P5Q>@ll!Lzz-6BCA)NAq*?&*?*BA)NO3%LC9KRVV6:%<=FGd=e%ff )K)KK '00<3H3HH,,33L4L4LMq5 EEKK59M8M:<'',BUBU:V9W2X,YYK!uu{{Q.1 %T *QrU&GGIJJ+-779aDRZ(T+-><<#d;.?jAQ*RRVWW[][b[b[d C(k'')p%&84F+G__RWW49;9L9L9S9S575F5F-H  2: E EF "  |R->->W'( UV KK!2!2 33JJqy ? ?g%NN:.NN:.K   t||DNN4D'E!%) AID  bggEg&:!; <&:)>})MM}} *(=k(JJ BGGI-"bggEg&::!RWW5W%99"$--D ' 5 EDO V ! mz  GGNN4 {{bggiV444  w"  r*Oh  s* 'q*q:  q?* q76q7? r  r cgSrWr+rs r-no_constraintsr Ps Ir,cdfd}t|}|D]}|j|||}| |||_|S)zAtry to figure a good logging value from various verbosity optionsc||}|jdd}tj|}|S#ttf$rY(wxYw#t $rY|SwxYw)N#r)rrrr;r<r)rrOr|s r-rNz_al_set_logging..getUsX cFaQ!!!$Q *0D04 s 1AAA AAcd|vr|dSd|vr |ddkryd|vr%|d}d|vr |dSd|vr|ddkryyyy)NrrrFrrr+)r4korNs r-extract_logging_valuez._al_set_logging..extract_logging_value\sz  )$ $  3vy#9R#?   "BR2z**B3r9#5#;$< r,)rvrr)alr4 more_kwargsrr'rrNs @r-_al_set_loggingrSsN &\F  a#F+Gr~ Nr,c Jd|vr tdr)tk7r ttrdkr tdt |j dgr |dg|d<ggt jt|a tt|tj|rit jt jt jt jt jt j gngfdfdfd}fd } fd } |dj#| | g|j d ij d dt%|||fi|\} } tg| _t| _| _rՈfd } |j-}d|j d id<t%| | j.j0| j2fi|\} }|j4j6dk(rt9|j4j:| j*j=dgd|j4j:|j4j:dd| j*j:| fS|j.j0}||}}t?|Dcgc]}|dk c}rqt?|Dcgc] }|dzdzkc}rOt9|}| j*j=||d|||tA|tA|z|d|| fStCjDd| jFd| _$| j.j0| fScc}wcc}w)a7DEPRECATED: use `cma.ConstrainedFitnessAL` or `cma.fmin_con2` instead. Optimize f with constraints g (inequalities) and h (equalities). Construct an Augmented Lagrangian instance ``f_aug_lag`` of the type `cma.constraints_handler.AugmentedLagrangian` from `objective_function` and `g` and `h`. Equality constraints should preferably be passed as two inequality constraints like ``[h - eps, -h - eps]``, with eps >= 0. When eps > 0, also feasible solution tracking can succeed. Return a `tuple` ``es.results.xfavorite:numpy.array, es:CMAEvolutionStrategy``, where ``es == cma.fmin2(f_aug_lag, x0, sigma0, **kwargs)[1]``. Depending on ``kwargs['logging']`` and on the verbosity settings in ``kwargs['options']``, the `AugmentedLagrangian` writes (hidden) logging files. The second return value:`CMAEvolutionStrategy` has an (additional) attribute ``best_feasible`` which contains the information about the best feasible solution in the ``best_feasible.info`` dictionary, given any feasible solution was found. This only works with inequality constraints (equality constraints are wrongly interpreted as inequality constraints). If `post_optimization` is set to True, then the attribute ``best_feasible`` of the second return value will be updated with the best feasible solution obtained by optimizing the sum of the positive constraints squared starting from the point ``es.results.xfavorite``. Additionally, the first return value will be the best feasible solution obtained in post-optimization. In case when equality constraints are present and a "feasible" solution is requested, then `post_optimization` must be a strictly positive float indicating the error on the inequality constraints. The second return value:`CMAEvolutionStrategy` has also a `con_archives` attribute which is nonempty if `archiving`. The last element of each archive is the best feasible solution if there was any. See `cma.fmin2` for the further parameters ``**kwargs``. >>> import cma >>> x, es = cma.evolution_strategy.fmin_con( ... cma.ff.sphere, 3 * [0], 1, g=lambda x: [1 - x[0]**2, -(1 - x[0]**2) - 1e-6], ... options={'termination_callback': lambda es: -1e-5 < sum(es.mean**2) - 1 < 1e-5, ... 'verbose':-9}) >>> assert 'callback' in es.stop() >>> assert es.result.evaluations < 1500 # 10%-ish above 1000, 1%-ish above 1300 >>> assert (sum(es.mean**2) - 1)**2 < 1e-9, es.mean >>> x, es = cma.evolution_strategy.fmin_con( ... cma.ff.sphere, 2 * [0], 1, g=lambda x: [1 - x[0]**2], ... options={'termination_callback': lambda es: -1e-8 < sum(es.mean**2) - 1 < 1e-8, ... 'seed':1, 'verbose':-9}) >>> assert es.best_feasible.f < 1 + 1e-5, es.best_feasible.f >>> ".info attribute dictionary keys: {0}".format(sorted(es.best_feasible.info)) ".info attribute dictionary keys: ['f', 'g', 'g_al', 'x']" Details: this is a versatile function subject to changes. It is possible to access the `AugmentedLagrangian` instance like >>> al = es.augmented_lagrangian >>> isinstance(al, cma.constraints_handler.AugmentedLagrangian) True >>> # al.logger.plot() # plots the evolution of AL coefficients >>> x, es = cma.evolution_strategy.fmin_con( ... cma.ff.sphere, 2 * [0], 1, g=lambda x: [y+1 for y in x], ... post_optimization=True, options={"verbose": -9}) >>> assert all(y <= -1 for y in x) # assert feasibility of x rz?`parallel_objective` parameter is not supported by cma.fmin_conrzWhen equality constraints are given, the argument``post_optimization`` must be a strictly positive float indicating the error on the inequality constraintsrcNjt|dS)Nr)rr)rrr0s r-r9zfmin_con..fs# +A./0u r,ch||}}tjgtjt|t|zt j t|dgzt|dgzzdt_jt|t|zdS)NFTr]rr) _alrset_mrrr _equalityrr)rr+hvalsrrhs r-rzfmin_con..constraintsstQqTu 77? IIc%j3u:- .JJs5zUG';c%jD6>Q'Q-35CM etE{*+u r,c bt | |}}t|}t|Dcgc]}|dk c}rj||||||||dt j tj ||||}D]}|j||||t|zScc}w)Nr)rr9rg_alr)rrrrrr"r#r) rr*r+r,rrr)archivesbest_feasible_solutionrr9s r-auglagzfmin_con..auglagsadm[^eU %(%Ba%( ) " ) )$vq$E&B * C$99OOQeV=A HHT5$ 'c&k!!)s B,cHtjggcddddyrW)rr)rrrs r-rz"fmin_con..set_coefficientss& Q" !adr,cv|jddd}tj||y)Nrr)r)rrr)rrrr9s r-rzfmin_con..updates0 FF1F "1 % 1Q4Q(r,rrc |ttd|Dtfd|DzS)Nc32K|]}|dkDs |dzywrr+rs r-rtz+fmin_con..f_post..s@2arQwrc3@K|]}|dzdzkDs|dzyw)r"Nr+)rqhipost_optimizations r-rtz+fmin_con..f_post..s-GW-1rR1W?PTU?U5U27Ts )rr)rrrr)s r-f_postzfmin_con..f_postsG3@1@@3GW-.qTGWDWWX Xr,rrN)rr9r)rrr")rr9rrz"Post optimization was unsuccessfulrr)%rr rrr/ setdefaultrrrrrrrr rrrextendrobjective_function_complementsrrurrrjr:rr9rrrrrrrr con_archives)r0r5r9rrr) archivingr4r"rrrrr* kwargs_postes_postx_postg_x_posth_x_postrr(f_x_postrrr r!rr9s` ``` @@@@@@r-fmin_conr6os_\v%Z[[Q.0,e48IQ8NTU U!!*b12$Z01z A A  2 23r7 ;CC  446 < <=Q=\=\ ] < <=Q=\=\ ] < <=Q=d=d e   ") :/89 i$//C &"f / /EAr),B%!B-B Xkkm ;< y"-i86299#6#6*(* 7 <<>>Q *7<<>>:;A    # #AtTW\\^^!(!"!% $  ##%%r) )))vY& ( (+(Ba(+ ,J2R1W 1Q 66JK1&9:H    # #Hh%+%-%)(^d8n%D%-  $ 2:     D(* (: <BO 99   ""!,Js  N0N c t|tst|tr td|i}|jdijddt d||}|||d<t j ||fd|i|} d|vs|d| jg|d<nt|d| jgz|d<t| ||fi|\} } | j| usJ|r| j| } |djd dr{|| jj} | j| t!|| | | j#| | j$j&} n| jj} | j$| _| j*| _| | fS#|dg| jgz|d<YxYw) aoptimize f with inequality constraints g. `constraints` is a function that returns a list of constraints values, where feasibility means <= 0. An equality constraint ``h(x) == 0`` can be expressed as two inequality constraints like ``[h(x) - eps, -h(x) - eps]`` with ``eps >= 0``. `find_feasible_...` arguments toggle to search for a feasible solution before and after the constrained problem is optimized. Because this can not work with equality constraints, where the feasible domain has zero volume, find-feasible arguments are `False` by default. `kwargs_confit` are keyword arguments to instantiate `constraints_handler.ConstrainedFitnessAL` which is optimized and returned as `objective_function` attribute in the second return argument (type `CMAEvolutionStrategy`). Other and further keyword arguments are passed (in ``**kwargs_fmin``) to `cma.fmin2`. Consider using `ConstrainedFitnessAL` directly instead of `fmin_con2`. zFound an unexected `dict` as argument. Recheck the calling signature. Use the keyword `options={...}` to pass an options argument for `fmin2`. Use the keyword syntax also for any further arguments passed to `fmin2`.Nrrrrfind_feasible_firstrr)rrvrr+rrConstrainedFitnessALrrrr0 find_feasiblerNrrj _update_bestrrrrrur r.)r0r5r9rr8find_feasible_final kwargs_confit kwargs_fminrr1rrrrs r- fmin_con2r?-s8%t, ;NPT0Ufg g 9b)44_aHdK?G#* i   3 3    3  C $ J(?(G#&::, J'+K ,C'D |'S[ $ #r6 1[ 1EAr C '' '   b ! y ! % %&7 >BII//0A   Q(:1(= >366!9 M A II  }}BllBO b5L' S;z+B*Cszzl*R J's F""F>r|rW)Nr+NrFr"FNNrrFNNN)hr* __future__rrr collectionsutilities.python3for2rrarrrGr;numpyrrr r'r r r r rr utilitiesrrrrr,rrcmarrrrrrrYrrrutilities.utilsrrrrrutilities.mathrrrsigma_adaptationr rQrr!r$r r r_wherer use_archives version_inforrrrr UserWarningr%r1r5r:r7rvr8 _debuggingr_assertions_quadratic_assertions_cubic _depreciated namedtuplerdobjectrnrxr OOOptimizerrrrrisnanrrrrr rr6r?r+r,r-rUssV(   &?691EE/!6":11$(![%(",\[ [  no & ))U2I U**e3K*.&;  e@{@  %Q 3-3j  T  *  *!7!7!7 # "*XYe&Yev-%-^S3:11S3jfD?&D?L4BA?F;?a""((m`  %&Wt A F:5|#~(!&!& Fr,