J-jTBdZddlmZmZmZddlZddlmZ[[[GddeZ Gdd eZ Gd d eZ Gd d eZ y#dZY6xYw)z2Very few interface defining base class definitions)absolute_importdivisionprint_functionN) EvalParallel2c*eZdZdZdZddZdZdZy) EvalParallelz7allow construct ``with EvalParallel(fun) as eval_all:``c||_yNfun)selfr argskwargss \/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/interfaces.py__init__zEvalParallel.__init__ s cN|Dcgc]}|j|g|c}Scc}wr r )rXrxs r__call__zEvalParallel.__call__ s*,-.Aq"T"A...s"c|Sr rs r __enter__zEvalParallel.__enter__srcyr rrrrs r__exit__zEvalParallel.__exit__srN)r)__name__ __module__ __qualname____doc__rrrrrrrr r sA/$-rr cdeZdZdZdZdZdZdZdZd dZ e d Z dd Z d Z d Zy) OOOptimizeraabstract base class for an Object Oriented Optimizer interface. Relevant methods are `__init__`, `ask`, `tell`, `optimize` and `stop`, and property `result`. Only `optimize` is fully implemented in this base class. Examples -------- All examples minimize the function `elli`, the output is not shown. (A preferred environment to execute all examples is ``ipython``.) First we need:: # CMAEvolutionStrategy derives from the OOOptimizer class from cma import CMAEvolutionStrategy from cma.fitness_functions import elli The shortest example uses the inherited method `OOOptimizer.optimize`:: es = CMAEvolutionStrategy(8 * [0.1], 0.5).optimize(elli) The input parameters to `CMAEvolutionStrategy` are specific to this inherited class. The remaining functionality is based on interface defined by `OOOptimizer`. We might have a look at the result:: print(es.result[0]) # best solution and print(es.result[1]) # its function value Virtually the same example can be written with an explicit loop instead of using `optimize`. This gives the necessary insight into the `OOOptimizer` class interface and entire control over the iteration loop:: # a new CMAEvolutionStrategy instance optim = CMAEvolutionStrategy(9 * [0.5], 0.3) # this loop resembles optimize() while not optim.stop(): # iterate X = optim.ask() # get candidate solutions f = [elli(x) for x in X] # evaluate solutions # in case do something else that needs to be done optim.tell(X, f) # do all the real "update" work optim.disp(20) # display info every 20th iteration optim.logger.add() # log another "data line", non-standard # final output print('termination by', optim.stop()) print('best f-value =', optim.result[1]) print('best solution =', optim.result[0]) optim.logger.plot() # if matplotlib is available Details ------- Most of the work is done in the methods `tell` or `ask`. The property `result` provides more useful output. cN||_||_||_|jy)z"``xstart`` is a mandatory argumentN)xstartmore_mandatory_argsoptional_kwargs initialize)rr&r'r(s rrzOOOptimizer.__init__Ls# #6 . rctd)z(re-)set to the initial statez8method initialize() must be implemented in derived class)NotImplementedError countiterr&xcurrent)rxis rr)zOOOptimizer.initializeRs!"\]]rc td)z|abstract method, AKA "get" or "sample_distribution", deliver new candidate solution(s), a list of "vectors" z1method ask() must be implemented in derived classr+)rr(s raskzOOOptimizer.askWs""UVVrcB|xjdz c_td)z\abstract method, AKA "update", pass f-values and prepare for next iteration rz2method tell() must be implemented in derived class)r,r+)r solutionsfunction_valuess rtellzOOOptimizer.tell\s !!"VWWrctd)aSabstract method, return satisfied termination conditions in a dictionary like ``{'termination reason': value, ...}`` or ``{}``. For example ``{'tolfun': 1e-12}``, or the empty dictionary ``{}``. TODO: this should rather be a property!? Unfortunately, a change would break backwards compatibility. z method stop() is not implementedr0rs rstopzOOOptimizer.stopbs""DEErNcy)zabstract method, display some iteration info when ``self.iteration_counter % modulo < 1``, using a reasonable default for `modulo` if ``modulo is None``. Nr)rmodulos rdispzOOOptimizer.displsrctd)zoabstract property, contain ``(x, f(x), ...)``, that is, the minimizer, its function value, ... z"result property is not implemented)r+r-rs rresultzOOOptimizer.resultqs ""FGGrc  <| r7dt| dkDrdnddt| d} tj| |!||kDrtjd||fz|}|j |}d \} } t xst ||d k(rdn|5} |jr| |kr|r| |k\s|r| |k\r |cdddS| dz } |j}| || }| t|z } |j|||D] }|| |j||js| |krddd|j||d kDr% |jd d kDr|j|S|S#1swYGxYw#t$r|r|jdtd|j td|j dtd|j d Y|S#t"t$t&t(tf$rYY|SwxYwY|SwxYw)a find minimizer of ``objective_fct``. CAVEAT: the return value for `optimize` has changed to ``self``, allowing for a call like:: solver = OOOptimizer(x0).optimize(f) and investigate the state of the solver. Arguments --------- ``objective_fct``: f(x: array_like) -> float function be to minimized ``maxfun``: number maximal number of function evaluations ``iterations``: number number of (maximal) iterations, while ``not self.stop()``, it can be useful to conduct only one iteration at a time. ``min_iterations``: number minimal number of iterations, even if ``not self.stop()`` ``args``: sequence_like arguments passed to ``objective_fct`` ``verb_disp``: number print to screen every ``verb_disp`` iteration, if `None` the value from ``self.logger`` is "inherited", if available. ``callback``: callable or list of callables callback function called like ``callback(self)`` or a list of call back functions called in the same way. If available, ``self.logger.add`` is added to this list. TODO: currently there is no way to prevent this other than changing the code of `_prepare_callback_list`. ``n_jobs=0``: number of processes to be acquired for multiprocessing to parallelize calls to `objective_fct`. Must be >1 to expect any speed-up or `None` or `-1`, which both default to the number of available CPUs. The default ``n_jobs=0`` avoids the use of multiprocessing altogether. ``return self``, that is, the `OOOptimizer` instance. Example ------- >>> import cma >>> es = cma.CMAEvolutionStrategy(7 * [0.1], 0.1 ... ).optimize(cma.ff.rosen, verb_disp=100) ... #doctest: +ELLIPSIS (4_w,9)-aCMA-ES (mu_w=2.8,w_1=49%) in dimension 7 (seed=...) Iterat #Fevals function value axis ratio sigma ... 1 9 ... 2 18 ... 3 27 ... 100 900 ... >>> cma.s.Mh.vequals_approximately(es.result[0], 7 * [1], 1e-5) True zignoring unkown argumentrs z in OOOptimizer.optimizeNz+doing min_iterations = %d > %d = iterations)rr)rr verb_dispztermination byzbest f-value =z solution =)lenstrwarningswarn_prepare_callback_listrr r7r1r5r:_force_final_loggingopts result_pretty Exceptionprintr<AttributeError TypeError IndexErrorKeyError)r objective_fctmaxfun iterationsmin_iterationsrrBcallbackn_jobsrmessagecitercevalseval_allrfitvalsfs roptimizezOOOptimizer.optimizeys"@ 6{QB.F =G MM   !nz&A MMG#Z01 2'J..x8 v+|]$*bLDf>AIiikU^%;v/5J#6 >>  HHJ"140#g,& !W%!AdG" )$iikU^%;>$ !!#   A  99[)A-&&( t C>>0 IIaL*DIIK8. A?lDKKN; +Iz8YW    sI%E9=A/E9-E9"F9F6H<2G11HHHHHc.|g}t|r|g} t||jjgz} |D]$}t|rt dt |z |S#t$rY8wxYw#t$rt dt |zwxYw)zreturn a list of callbacks including ``self.logger.add``. ``callback`` can be a `callable` or a `list` (or iterable) of callables. Otherwise a `ValueError` exception is raised. zStatisticalModelSamplerWithZeroMeanBaseClass.covariance_matrix\rrct)z.vector of coordinate-wise (marginal) variancesr0rs r variancesz6StatisticalModelSamplerWithZeroMeanBaseClass.variances_s "!rct)z;transform ``x`` as implied from the distribution parametersr0rs r transformz6StatisticalModelSamplerWithZeroMeanBaseClass.transformdrrctr r0rs rrz>StatisticalModelSamplerWithZeroMeanBaseClass.transform_inverseh!!rct)z2return inverse of associated linear transformationr0rresets r to_linear_transformation_inversezMStatisticalModelSamplerWithZeroMeanBaseClass.to_linear_transformation_inversekrrct)z'return associated linear transformationr0rs rto_linear_transformationzEStatisticalModelSamplerWithZeroMeanBaseClass.to_linear_transformationorrct)zreturn scalar correction ``alpha`` such that ``X`` and ``f`` fit to ``f(x) = (x-mean) (alpha * C)**-1 (x-mean)`` r0)rmeanrr\s r!inverse_hessian_scalar_correctionzNStatisticalModelSamplerWithZeroMeanBaseClass.inverse_hessian_scalar_correctionsrurctr r0)rfactors r__imul__z5StatisticalModelSamplerWithZeroMeanBaseClass.__imul__yrrr NN)F)rr r!r"rrqrprrrhrrrrrrrrrrrrrjrjsv """  66"" "" """"""" "rrjcPeZdZdZdZdZd dZdZdZd dZ d d Z e d Z y) BaseDataLoggerzabstract base class for a data logger that can be used with an `OOOptimizer`. Details: attribute `modulo` is used in `OOOptimizer.optimize`. c2d|_ d|_ d|_y)Nz_BaseDataLogger_datadict.py)optim_datafilenamers rrzBaseDataLogger.__init__s  5 #5 Erc||_|S)z~register an optimizer ``optim``, only needed if method `add` is called without passing the ``optim`` argument )r)rrrrs rregisterzBaseDataLogger.registers  rNc t)zabstract method, add a "data point" from the state of ``optim`` into the logger. The argument ``optim`` can be omitted if ``optim`` was ``register`` ()-ed before, acts like an event handler r0)rr more_datars rrbzBaseDataLogger.adds "!rcDtdtt|zy)z(abstract method, display some data tracezEmethod BaseDataLogger.disp() not implemented, to be done in subclass NrLrDtypers rr:zBaseDataLogger.disps UX[\`ae\fXgghrcDtdtt|zy)zabstract method, plot datazHmethod BaseDataLogger.plot() is not implemented, to be done in subclass Nrrs rplotzBaseDataLogger.plots X[^_cdh_i[jjkrct|xs |jd5}|jt|jdddy#1swYyxYw)z+save data to file `name` or `self.filename`wN)openrwritereprr)rnamer\s rsavezBaseDataLogger.saves8 $'$-- - GGD$ %. - -s %A  Acddlm}t|xs |jd5}||j |_ddd|S#1swY|SxYw)z-load data from file `name` or `self.filename`r) literal_evalrN)astrrrreadr)rrrr\s rloadzBaseDataLogger.loadsA$ $'$-- -%affh/DJ. . s AAc|jS)zlogged data in a dictionary)rrs rdatazBaseDataLogger.dataszzrrr ) rr r!r"rrrbr:rrrrhrrrrrr|sA F"il&  rr) r" __future__rrrrEoptimization_toolsrobjectr r$rjrrrrrs]8@@2X~.6.H &H T_"6_"B5V5o  s AA