J-jefdZddlmZmZmZddlZddlZddlZddlZ ddl m Z ddl mZddlmZddlmZ[[[d d Zd!d Zd"d ZGd d eZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZ GddeZ!y)#zDUtility classes and functionalities loosely related to optimization )absolute_importdivisionprint_functionN)Pool) BlancClass)math)rangec ddlm}|M|||}}nF ddlm}|j j j d}|dd|f|ddd df}}tj|d }|d vr ||z}nddkr |rtj|n\ttjtj tjtj"||dk7} tj"|d| zk} |d| zk\} |d| z k} tj|| | z || <tj||  | z || <d|| <|td|jddz}d|vr}|j%d}t'tj(|j*D].\} }|j,||fd| t|kr|| ndi|0|j/dn*|j,||fi|d|vr|j/d|j1}gg}}|j3D]b}d|| zz}|dkr d| | zz}n |dk(rd| z}d|vr/|ddk(r|dd|ddz}|ddk(r|ddk(r |dd|ddz}||gz }||gz }d|j5||j7||j9d y#tjdd }YxYw#t|jdD cgc]} || t|kr| ndncc} w}} ||z}YxYw)asigned semilogy plot. ``plt.yscale('symlog', linthreshy=min(abs(data[data != 0])))`` should do the same job as least as good. `y` (or `x` if `y` is `None`) is a data array, by default read from `outcmaesxmean.dat` or (first) from the default logger output file like:: xy = cma.logger.CMADataLogger().load().data['xmean'] x, y = xy[:, iabscissa], xy[:, 5:] semilogy_signed(x, y) Plotted is `y - yoffset` vs `x` for positive values as a semilogy plot and for negative values as a semilogy plot of absolute values with inverted axis. `minabsy` controls the minimum shown value away from zero, which can be useful if extremely small non-zero values occur in the data. rpyplotNr)loggerxmeanzoutcmaesxmean.dat)%)commentsT)copyNr  labelslabel皙?) framealphaz $10^{%.2f}$z $-10^{%.2f}$z$\pm10^{%.2f}$.0) matplotlibr r CMADataLoggerloaddatanploadtxtarrayr shapelenlog10intfloorminabspop enumerateasarrayTplotlegendgca get_yticks set_yticksset_yticklabelsgrid)xyyoffsetminabsy iabscissakwargspltrxyimin_log idx_zerosidx_posidx_neg kwargs_labelsyiaxticksrvalss d/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/optimization_tools.pysemilogy_signedrOs^.)y =aqA F$))+00277@al#R12YqA Ai  LA a #*bhhw"((266"((266!AqD'?";<=> q BK'I2w;GBK<G!G*%/AgJ88QwZK(723AgJAiLy !QWWQZ!^ $6 8, rzz!}/EAr CHHQ aa#m:L6L-"2RV aZ` a0 c "A  f  JJ#J & B6E}} g . 7 cTG^4A AX"g-A !8B%3,crFQrsVOB%3,u|crFQrsVO1#  #MM%vHHTNi FZZ 3fE  GLQWWUVZGXYGX!wAG $4q"=GXYGY LAs#1K'2L'LM"L?> Mc .||}tj||\}}|j}tt |D]M}tt |dD]1}|tj ||||||g|||<3O|||fS)agenerate x,y,z-data for contour plot. `fct` is a 2-D function. `x`- and `y_range` are `iterable` (e.g. `list` or arrays) to define the meshgrid. CAVEAT: this function calls `fct` ``len(list(x_range)) * len(list(y_range))`` times. Hence using `Sections` may be the better first choice to investigate an expensive function. Examples: >>> from cma import optimization_tools >>> import numpy as np ... >>> def plt_contour(): # def avoids doctest execution ... from matplotlib import pyplot as plt ... ... X, Y, Z = optimization_tools.contour_data( ... lambda x: sum([xi**2 for xi in x]), ... np.arange(0.90, 1.10, 0.02), ... np.arange(-0.10, 0.10, 0.02)) ... CS = plt.contour(X, Y, Z) ... plt.gca().set_aspect('equal') ... plt.clabel(CS) >>> def plt_surface(): # def avoids doctest execution ... from matplotlib import pyplot as plt ... from mpl_toolkits import mplot3d ... ... X, Y, Z = optimization_tools.contour_data( ... lambda x: sum([xi**2 for xi in x]), ... np.arange(-1, 1.1, 0.02)) ... ax = plt.axes(projection='3d') ... ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none') See `cma.fitness_transformations.FixVariables` to create a 2-D function from a d-D function, e.g. like >>> import cma ... >>> fd = cma.ff.elli >>> x0 = np.zeros(22) >>> indices_to_vary = [2, 4] >>> f2 = cma.fitness_transformations.FixVariables(fd, ... dict((i, x0[i]) for i in range(len(x0)) ... if i not in indices_to_vary)) >>> isinstance(f2, cma.fitness_transformations.FixVariables) True >>> isinstance(f2, cma.fitness_transformations.ComposedFunction) True >>> f2[0] is fd, len(f2) == 2 (True, True) r)r&meshgridrr r*r2)fctx_rangey_rangeXYZrCjs rN contour_datarYesn ;;w (DAq A 3q6]s1Q4y!A"**ad1gqtAw%789AaDG" a7Nc tjt|}tjddt |dzd}|rxtj ||tj dgtj|gzz ||||tj tj|dggzzg}ntj ||g}|j|jd}|rDtj |ddd|z |ddz||ddzz||ddzd|z |ddzz|ddg}ntj |dd|ddg}|j|jd}||fS) z\return x, y ECDF data for ECDF plot. Smoothing may look strange in a semilogx plot. rrT)endpointF)orderNr) r&r2sortedlinspacer*r(hstackdiffreshapesize)r%smooth_cornersr;r<s rN step_datarfsq 6$< A Aq#a&1*t4A HHa.299qc2771:5F+GGGABGGAJ;L1M MMO P HHaV  !&& $A HHafq>1QsV;nqQRQSu>TT$q"v-^1Cqu0LLaPQPReU V!CR&!AB%)A !&& $A a4KrZc8eZdZdZd dZd dZdZdZdZdZ y) EvalParallel2a A class and context manager for parallel evaluations. This class is based on the ``Pool`` class of the `multiprocessing` module. The interface in v2 changed, such that the fitness function can be given once in the constructor. Hence the number of processes has become the second (optional) argument of `__init__` and the function has become the second and optional argument of `__call__`. To be used with the `with` statement (otherwise `terminate` needs to be called to free resources):: with EvalParallel2(fitness_function) as eval_all: fvals = eval_all(solutions) assigns a callable `EvalParallel2` class instance to ``eval_all``. The instance can be called with a `list` (or `tuple` or any sequence) of solutions and returns their fitness values. That is:: eval_all(solutions) == [fitness_function(x) for x in solutions] `EvalParallel2.__call__` may take three additional optional arguments, namely `fitness_function` (like this the function may change from call to call), `args` passed to ``fitness`` and `timeout` passed to the `multiprocessing.pool.ApplyResult.get` method which raises `multiprocessing.TimeoutError` in case. ``eval_all = EvalParallel2(fitness_function, 0)`` bypasses `multiprocessing`, hence the construct can be used even when `multiprocessing` fails on this `fitness_function` instantiation. Examples: >>> from cma.optimization_tools import EvalParallel2 >>> for n_jobs in [None, -1, 0, 1, 2, 4]: ... with EvalParallel2(cma.fitness_functions.elli, n_jobs) as eval_all: ... res = eval_all([[1,2], [3,4]]) >>> # class usage, don't forget to call terminate >>> ep = EvalParallel2(cma.fitness_functions.elli, 4) >>> [float(v) for v in ep([[1,2], [3,4], [4, 5]])] # doctest:+ELLIPSIS [4000000.944... >>> ep.terminate() ... >>> # use with `with` statement (context manager) >>> es = cma.CMAEvolutionStrategy(3 * [1], 1, dict(verbose=-9)) >>> with EvalParallel2(cma.fitness_functions.elli, ... number_of_processes=12) as eval_all: ... while not es.stop(): ... X = es.ask() ... es.tell(X, eval_all(X, args=(1e1,))) # `eval_all` also accepts ... # `fitness_function` as ... # (optional) keyword argument >>> assert es.result[1] < 1e-13 and es.result[2] < 1500 Parameters: the `EvalParallel2` constructor takes the number of processes as optional input argument, which is by default ``multiprocessing.cpu_count()``. If ``number_of_processes <= 0``, no `multiprocessing` is invoked and the fitness is computed directly in a regular loop. Limitations: the `multiprocessing` module, on which this class is based upon, may not work with certain class instance methods or Cython instances, or class instances that contain modules as it uses `pickle`. Details: in some cases the execution may be considerably slowed down, as for example in previous tests done with test suites from coco/bbob. Comparing setting ``number_of_processes = 0`` with ``number_of_processes = 1`` evaluates the overhead introduced by ``multiprocessing.Pool.apply_async``. Nc||_||_|j|jdkDrt|j|_yd|_yr)fitness_function processesProcessingPoolpool)selfrjnumber_of_processess rN__init__zEvalParallel2.__init__s= 0, >> !T^^a%7&t~~6DIDIrZc8|xs |j}| td|js|Dcgc] }||g| c}Sd}tjddk(r4t |t |jrtj||Dcgc]"}|jj||f|z$}} |Dcgc]}|j|c}Scc}wcc}wcc}w#tjddk(xrtj|xYw)aevaluate a list/sequence of solution-"vectors", return a list of corresponding f-values. `args` must be a tuple and is passed to `fitness_function` like ``fitness_function(solutions[0], *args)``. For example, a single argument, say `a1`, should be passed like ``args=(a1, )``. Raises `multiprocessing.TimeoutError` if `timeout` is given and exceeded. zN`fitness_function` was never given, must be passed in `__init__` or `__call__`z`fitness_function` must be a function, not a `lambda` or an instancemethod, in order to work with `multiprocessing` under Python 2r) rj ValueErrorrmsys version_info isinstancetyperpwarningswarn apply_asyncget) rn solutionsrjargstimeoutr; warning_strjobsjobs rN__call__zEvalParallel2.__call__ s*,Dt/D/D  #CD Dyy8AB 1$Q.. B B;    A ! #*D,?@ k*"$"A %%&6t D" $ 045CGGG$5 5C$6    Q 1 $ C{)C s)C'C;C)?C$C)$C))0Dc|jsy|jj|jjy)zfree allocated processing poolN)rm terminatejoinrns rNrzEvalParallel2.terminate,s*yy   rZc|SNrs rN __enter__zEvalParallel2.__enter__4s  rZc$|jyrr)rnexc_type exc_value tracebacks rN__exit__zEvalParallel2.__exit__9s  rZc$|jy)z rZrhc@eZdZdZdej dfdZddZdZy) BestSolutionzlcontainer to keep track of the best solution seen. Keeps also track of the genotype, if available. Nc||_d|_||tjur|ntj |_||_||_d|_ t|_ ||j_||j_y)z|initialize the best solution with ``x``, ``f``, and ``evals``. Better solutions have smaller ``f``-values. Nr) r;x_genor&nanr inffevalsevalsallcompared _BlancClasslast)rnr;rrs rNrpzBestSolution.__init__Esd  mTXX   =M   rZct|tr|j|j|_n2|j&t|j|jf|_|jQ|jt j kr4|j|jg||jg|j|xj|jz c_ |S|J|xjt|z c_ tj|}|tjuryt||t r||n t#||}|t j kr||jks |j|||_||_|?|j%|j$||jj%d|_nd|_|sdn|t|z t!|zdz|_ ||_n |r||_|||j(_||j(_y#t$rYywxYw)azchecks for better solutions in list ``arx``. Based on the smallest corresponding value in ``arf``, alternatively, `update` may be called with a `BestSolution` instance like ``update(another_best_solution)`` in which case the better solution becomes the current best. ``xarchive`` is used to retrieve the genotype of a solution. Ngenor)rvrrmaxrr rupdater;rrr*r& nanargminrsrr,floatr{rr)rnarxxarchivearfrminidxminarfs rNrzBestSolution.updateTs c< (}}$ #  ) #T]]CLL$A B uu SUUTXX%5 SUUGXw B MMS\\ )MK S!  \\#&F RVV   *3v; <V%F BT DHH &466/TVV^[DFDF# TVV(<(H&tvv.226: " %*C0@3v;0NQR0RDJ!DM !DM&k  '   sH44 I?IcH|j|j|jfS)zreturn ``(x, f, evals)`` )r;rrrs rNr{zBestSolution.getsvvtvvtzz))rZNNN) rrrrr rrprr{rrZrNrr@s$+X*rZrc$eZdZdZdZddZdZy) BestSolution2z=minimal tracker of a smallest f-value with variable meta-infocvtj|_d|_d|_d|_d|_ d|_yr)r rrr;info count_savedcountpreviousrs rNrpzBestSolution2.__init__s4  - rZNc|xjdz c_|jdk(sCtj|rtj|jr||jkrjt |j |_|j d=tj||_||_ |r||n||_ |j|_ |S)z`info` may be a dictionary with everything we want to know, `info_construct` may be used to finalize versatile elements of `info`, like make a copy of an array within the info dictionary rr) rr&isfiniterdict__dict__r_umifloatr;rr)rnrr;rinfo_constructs rNrzBestSolution2.updates a ::?r{{1~r{{4667JaRVRXRXj /DM j)ZZ]DFDF0>t,DDI#zzD  rZc,t|jSr)strrrs rN__str__zBestSolution2.__str__s4==!!rZr)rrrrrprrrrZrNrrsG "rZrceZdZdZddZy)BestFeasibleSolutioncJtj|d|_d|_yr)rrpg al_penaltiesrs rNrpzBestFeasibleSolution.__init__st$ rZNctd|Dr|Stj||||||j|jk(r4t j ||_t j ||_|S)z=g and al_penalties are lists of constraint and penalty valuesc3&K|] }|dkD yw)rNr).0gis rN z.BestFeasibleSolution.update..s""rAvs) anyrrrrrlifloatrr)rnrrrr;rrs rNrzBestFeasibleSolution.updatesb "" "KT1a~>   tzz )[[^DF # L 9D  rZ)NNNN)rrrrprrrZrNrrs !rZrc0eZdZdZddfdZdZdZdZy)ExponentialSmoothingznot in use (yet) Exponentially smoothened vector, new data are added via calling the class instance. The `normalizer` is applied to the weight ``1 / time_constant`` used for the new data. Nc|Srrr;s rNzExponentialSmoothing.srZc||_|j'|jdkrtd|jz||_d|_d|_y)Nrztime_constant = %d must be >=1r) time_constantrs normalizervaluesr)rnrrs rNrpzExponentialSmoothing.__init__sO*    )d.@.@1.D=@R@RRS S$  rZctj|t|_|jdt |dzz|_yy)N)dtyper?)r&r(rrrr*)rnvs rN_init_zExponentialSmoothing._init_s9hhq.    %!"SVS[D  &rZc |j|Srr)rnrCs rN __getitem__z ExponentialSmoothing.__getitem__s{{1~rZcp|j|j||xjdz c_tj|j|j f}|xjdd|z z zc_|xj|j d|z tj|zz c_|S)Nr)rrrr&r.rrr2)rnrtcs rNrzExponentialSmoothing.__call__s ;;  KKN a VVTZZ!3!34 5 q1r6z!  tq2v.A>>  rZ)rrrrrprrrrrZrNrrs"&*k1 rZrc4eZdZdZdfd ZedZxZS) EvolutionPathNnot in use (yet) A variance-neutral exponentially smoothened vector. c0tt| |dy)Nc8tj|d|z zS)Nrr)r&sqrtrs rNrz(EvolutionPath.__init__..sRWWQ!a%[%9rZ)superrrp)rnr __class__s rNrpzEvolutionPath.__init__s mT+ 9 ;rZc|jSrrrs rNpathzEvolutionPath.paths {{rZr)rrrrrppropertyr __classcell__)rs@rNrrs!;rZrc4eZdZedZedZddZy)BinaryEvolutionPathcztjdddtj|jdzz zS)a*propability of path entries to be larger than one, given the input is ``sign(randn())``. Check out:: n = int(1e4) greater_than_one = [] ar_tc = [1.2, 1.5, 1.9, 2, 4, 8, 16, 32, 100] for tc in ar_tc: p = cma.optimization_tools.EvolutionPath(tc) for i in range(int(10 * tc)): p(np.sign(np.random.randn(n))) # plot(*step_data(p.path)) greater_than_one += [(np.mean(p.path > 1) + np.mean(p.path < -1)) / 2] g?g |N?g?gffffff?)r&minimumr2rrs rN'probability_larger_than_one_from_binaryz;BinaryEvolutionPath.probability_larger_than_one_from_binarys>"zz$ 3"**T-?-?"@#"EE!FG GrZc`tj|jdkD|jz S)zreturn one of two possible values with expectation of zero. the maximum for the larger value is 1 - 0.15865525393145707 for tc to infty. r)r&r/rrrs rN raw_binary_sz BinaryEvolutionPath.raw_binary_ss't{{#a'4+W+WWWrZc>|j}||dkDxx|zcc<|S)z9how many increments for one decrement in stationary stater)r)rnodds_of_incrementrMs rNbinary_szBinaryEvolutionPath.binary_ss%    !a%%%rZN)r)rrrrrrrrrZrNrrs1 GG&XXrZrceZdZdZddZdZy)OldEvolutionPathrNctj||_d|_||_|dt |dzz|_yy)Nrrr)r&r2rrrr*)rnp0rs rNrpzOldEvolutionPath.__init__s@JJrN  *  !"SWc\!1D  !rZc|xjdz c_td|jz d|jz f}|xjd|z zc_|xj|d|z zdzt j |zz c_y)Nr?rrr)rrrrr&r2)rnrcs rNrzOldEvolutionPath.update sk a TZZd&8&8!89 : QU  a1q5kC'"**Q-77 rZr)rrrrrprrrZrNrrs2 8rZrc\eZdZdZgdej dddfdZd dZdZd d Z d Z d Z y) NoiseHandleraNoise handling according to [Hansen et al 2009, A Method for Handling Uncertainty in Evolutionary Optimization...] The interface of this class is yet versatile and subject to changes. The noise handling follows closely [Hansen et al 2009] in the measurement part, but the implemented treatment is slightly different: for ``noiseS > 0``, ``evaluations`` (time) and sigma are increased by ``alpha``. For ``noiseS < 0``, ``evaluations`` (time) is decreased by ``alpha**(1/4)``. The (second) parameter ``evaluations`` defines the maximal number of evaluations for a single fitness computation. If it is a list, the smallest element defines the minimal number and if the list has three elements, the median value is the start value for ``evaluations``. `NoiseHandler` serves to control the noise via steps-size increase and number of re-evaluations, for example via `fmin` or with `ask_and_eval`. Examples -------- Minimal example together with `fmin` on a non-noisy function: >>> import cma >>> res = cma.fmin(cma.ff.elli, 7 * [1], 1, noise_handler=cma.NoiseHandler(7)) #doctest: +ELLIPSIS (4_w,9)-aCMA-ES (mu_w=2.8,... >>> assert res[1] < 1e-8 >>> res = cma.fmin(cma.ff.elli, 6 * [1], 1, {'AdaptSigma':cma.sigma_adaptation.CMAAdaptSigmaTPA}, ... noise_handler=cma.NoiseHandler(6)) #doctest: +ELLIPSIS (4_w,... >>> assert res[1] < 1e-8 in dimension 7 (which needs to be given tice). More verbose example in the optimization loop with a noisy function defined in ``func``: >>> import cma, numpy as np >>> func = lambda x: cma.ff.sphere(x) * (1 + 4 * np.random.randn() / len(x)) # cma.ff.noisysphere >>> es = cma.CMAEvolutionStrategy(np.ones(10), 1) #doctest: +ELLIPSIS (5_w,10)-aCMA-ES (mu_w=3.2,... >>> nh = cma.NoiseHandler(es.N, maxevals=[1, 1, 30]) >>> while not es.stop(): ... X, fit_vals = es.ask_and_eval(func, evaluations=nh.evaluations) ... es.tell(X, fit_vals) # prepare for next iteration ... es.sigma *= nh(X, fit_vals, func, es.ask) # see method __call__ ... es.countevals += nh.evaluations_just_done # this is a hack, not important though ... es.logger.add(more_data = [nh.evaluations, nh.noiseS]) # add a data point ... es.disp() ... # nh.maxevals = ... it might be useful to start with smaller values and then increase ... # doctest: +ELLIPSIS Iterat... >>> print(es.stop()) ... # doctest: +ELLIPSIS {... >>> print(es.result[-2]) # take mean value, the best solution is totally off ... # doctest: +ELLIPSIS [... >>> assert sum(es.result[-2]**2) < 1e-9 >>> print(X[np.argmin(fit_vals)]) # not bad, but probably worse than the mean ... # doctest: +ELLIPSIS [... >>> # es.logger.plot() The command ``logger.plot()`` will plot the logged data. The noise options of fmin` control a `NoiseHandler` instance similar to this example. The command ``cma.CMAOptions('noise')`` lists in effect the parameters of `__init__` apart from ``aggregate``. Details ------- The parameters reevals, theta, c_s, and alpha_t are set differently than in the original publication, see method `__init__`. For a very small population size, say popsize <= 5, the measurement technique based on rank changes is likely to fail. Missing Features ---------------- In case no noise is found, ``self.lam_reeval`` should be adaptive and get at least as low as 1 (however the possible savings from this are rather limited). Another option might be to decide during the first call by a quantitative analysis of fitness values whether ``lam_reeval`` is set to zero. More generally, an automatic noise mode detection might also set the covariance matrix learning rates to smaller values. :See also: `fmin`, `CMAEvolutionStrategy.ask_and_eval` )rrrNgHz>FcV||_||_||_d|_d|_dd|dzz z|_dd|dzz z|_|j dz|_ddkr#|d d kDrd |_|j d z|_d|_ d|_ ttj||_ t|d rWt|dkDr!t!||_ |j|_t|d kDrtj"||_||_d|_d|_y)aParameters are: ``N`` dimension, (only) necessary to adjust the internal "alpha"-parameters ``maxevals`` maximal value for ``self.evaluations``, where ``self.evaluations`` function calls are aggregated for noise treatment. With ``maxevals == 0`` the noise handler is (temporarily) "switched off". If `maxevals` is a list, min value and (for >2 elements) median are used to define minimal and initial value of ``self.evaluations``. Choosing ``maxevals > 1`` is only reasonable, if also the original ``fit`` values (that are passed to `__call__`) are computed by aggregation of ``self.evaluations`` values (otherwise the values are not comparable), as it is done within `fmin`. ``aggregate`` function to aggregate single f-values to a 'fitness', e.g. ``np.median``. ``reevals`` number of solutions to be reevaluated for noise measurement, can be a float, by default set to ``2 + popsize/20``, where ``popsize = len(fit)`` in ``__call__``. zero switches noise handling off. ``epsilon`` multiplier for perturbation of the reevaluated solutions ``parallel`` a single f-call with all resampled solutions :See also: `fmin`, `CMAOptions`, `CMAEvolutionStrategy.ask_and_eval` rg333333?rg@rgпrrrrgNgmCg?g+ __contains__Nr) lam_reevalepsilonparallelthetacum alphasigma alphaevalsalphaevalsdown evaluationsminevalsr,r&rmaxevalshasattrr*r.medianmean f_aggregateevaluations_just_donenoiseS)rnNr  aggregatereevalsrrs rNrpzNoiseHandler.__init__qsF"    cQVn,cQVn,"oo5 6hqkD(!DO"&//6"9D P BFF8,- 8^ ,8}q #H  #'== 8}q #%99X#6 $%&" rZcd|_|jr|jdk(ry|j|||||}t |sy|j |j S)aproceed with noise measurement, set anew attributes ``evaluations`` (proposed number of evaluations to "treat" noise) and ``evaluations_just_done`` and return a factor for increasing sigma. Parameters ---------- ``X`` a list/sequence/vector of solutions ``fit`` the respective list of function values ``func`` the objective function, ``fit[i]`` corresponds to ``func(X[i], *args)`` ``ask`` a method to generate a new, slightly disturbed solution. The argument is (only) mandatory if ``epsilon`` is not zero, see `__init__`. ``args`` optional additional arguments to ``func`` Details ------- Calls the methods `reeval`, `update_measure` and ``treat` in this order. ``self.evaluations`` is adapted within the method `treat`. rr)rr rreevalr*update_measuretreat)rnrUfitfuncaskr}ress rNrzNoiseHandler.__call__sY8&'"}}1 4kk!S$T23x zz|rZc|jdkDr?t|j|jz|jf|_|j St |j|jz|jf|_y)zadapt self.evaluations depending on the current measurement value and return ``sigma_fac in (1.0, self.alphasigma)`` rr) rr.r rr rrrr rs rNrzNoiseHandler.treatsh ;;?"D$4$4t$F #VWD ?? ""D$4$4t7J7J$JDMM#Z[D rZc t||_t||_|j||_t |js |jS|j rt|jnd}|j tjn |j }|jD]}||} |jr|jr/||||| |jg||j|<O|t|D cgc] } ||d| |jdg|"c} |j|<|t|D cgc] } || g| c} |j|<|t |jz|_|j|j|jfScc} wcc} w)zstore two fitness lists, `fit` and ``fitre`` reevaluating some solutions in `X`. ``self.evaluations`` evaluations are done for each reevaluated fitness value. See `__call__`, where `reeval` is called. rr)listrfitreindicesidxr*rr,r r&r rrr r) rnrUrrrr}rfaggrCX_i_ks rNrzNoiseHandler.reevals9#Y <<$488}88O)-)9)9D$$%q ,,4ryy$:J:JAA$C||==$(c%dll.K)Sd)S$TDJJqM$(6;El*D6B+/s1c4<!?@AB B q[BJJsO4JKK3s8c#h.A#A8LEu5u!s1vu56 6 q[::bjjo.AqHqL/ABCIXN NJ%&' ' 6s5F)Nr)r) rrrrr&r rprrrrr!rrZrNrrs<\@$- teAF#J .84'rZrcteZdZdZ ddZdededDdfdZdd fd Zd Z dd Z dd Z y)Sectionsaplot sections through an objective function. A first rational thing to do, when facing an (expensive) application. By default 6 points in each coordinate are evaluated. The data is saved and reloaded by default. A change of basis will invalide the loaded result. This class is still experimental. Examples -------- :: import cma, numpy as np s = cma.Sections(cma.ff.rosen, np.zeros(3)).do(plot=False) s.do(plot=False) # evaluate the same points again, i.e. check for noise try: s.plot() except: print('plotting failed: matplotlib.pyplot package missing?') Details ------- Data are saved after each function call during `do`. The filename is attribute ``name`` and by default ``str(func)``, see `__init__`. A random (orthogonal) basis can be generated with ``cma.transformations.Rotation()(np.eye(3))``. CAVEAT: The default name is unique in the function name, but it should be unique in all parameters of `__init__` but `plot_cmd` and `load`. If, for example, a different basis is chosen, either the name must be changed or the ``.pkl`` file containing the previous data must first be renamed or deleted. ``s.res`` is a dictionary with an entry for each "coordinate" ``i`` and with an entry ``'x'``, the middle point. Each entry ``i`` is again a dictionary with keys being different dx values and the value being a sequence of f-values. For example ``s.res[2][0.1] == [0.01, 0.01]``, which is generated using the difference vector ``s .basis[2]`` like ``s.res[2][dx] += func(s.res['x'] + dx * s.basis[2])``. :See also: `__init__` NTc|ddlm}||_||_||_|r|n:t |j ddj ddj dd|_||_|tjt|n||_ |xr|jt|jd |k7ri|_||jd <yt!|jd zy#i|_||jd <YyxYw) a Parameters ---------- ``func`` objective function ``x`` point in search space, middle point of the sections ``args`` arguments passed to `func` ``basis`` evaluated points are ``func(x + locations[j] * basis[i]) for i in len(basis) for j in len(locations)``, see `do()` ``name`` filename where to save the result ``plot_cmd`` command used to plot the data, typically matplotlib pyplots `plot` or `semilogy` ``load`` load previous data from file ``str(func) + '.pkl'`` Nr)r4 _>r"s/Px!SA xsc|s|jy|j}tt|jD]}||vri||<|D]}|j ||j|zz}|}|||vrg|||<|} | dkDs;| dz} |||j |j|g|j|r|j|j| dkDr_|S)aJgenerates, plots and saves function values ``func(y)``, where ``y`` is 'close' to `x` (see `__init__()`). The data are stored in the ``res`` attribute and the class instance is saved in a file with (the weired) name ``str(func)``. Parameters ---------- ``repetitions`` for each point, only for noisy functions is >1 useful. For ``repetitions==0`` only already generated data are plotted. ``locations`` coordinated wise deviations from the middle point given in `__init__` Nrr) r4rr r*rIr;appendrr}save) rn repetitions locationsr4rrCdxxxxkeyns rNdoz Sections.dos  IIK hhs4::'A|A VVb4::a=00s1v%#%CF4L!eFAF4L''  "(Atyy(AB IIK !e  (" rZc|Srr)r<s rNrzSections.sqrZc ddlm}|s |j}d}|jj |j }|j \}}tj}|D]} t|t|| f}|dkrd|z nd} td|jDD]} || t|z} t|| j} || | D cgc]&} |tj|| | | z(c} | dz|j| d|tj|| | d| t|| dks||| |tj || | z| t|| d krd nd z|j#d t%| z|j'|j)|j+|Scc} w) z&plot the data we have, return ``self``rr bgrcmykg& .>c3BK|]}t|ts|ywr)rvr,)rks rNrz Sections.plot..sD:aAs1C:s-r!rorzf + )r!r rGgcfclearr flattenedr rr.r_keysr*r&r textr(ylabelrdrawionshow)rnrGtfr colorsrflatxflatfminfrCaddfcolorrr;s rNr4z Sections.plots%}}H hh~~' uxxAc%(m,-D"dltd{D388:DDA1s6{?+EQ'C SCHCq2biiAq 2T9:CH%RU+ V KKBBIIc!fSWo$>!? C58}r!q2bhhuQx&84&?#@%RUV[\]V^R_bdRd3jmBno E  fs4y()    Is'+G: c4i}i}|jD]}t|tsg||<g||<t|j|D]J}t|j||D]*}||j |||j |,L||fS)zreturn flattened data ``(x, f)`` such that for the sweep through coordinate ``i`` we have for data point ``j`` that ``f[i][j] == func(x[i][j])`` )rrvr,r_rN)rnrjrkrCr;ds rNrazSections.flatteneds A!S!aa ,A#DHHQKN3a*a*4- e|rZcddl}|r|n |j}|j}|`|j|t |dzd||_|S)z save to filerN.pklwb)picklerFrdumpopen)rnrFrtfuns rNrOz Sections.savesEtii I D$tf}d34  rZcddl}|r|n |j}|jt|dzd}|j|_|S)zload from filerNrrrb)rtrFr$rvr)rnrFrtrMs rNr$z Sections.loads;t KKTF]D1 255 rZ)rNNNTr) rrrrrptupler rVr4rarOr$rrZrNr>r>;sP,Z;?%)*X%/PuQx/P*PW[&P![6$rZr>)NNrNrr)r)"r __future__rrrrtrxr numpyr&multiprocessingrrlutilities.utilsrr utilitiesrutilities.python3for2r rOrYrfobjectrhrrrrrrrrr>rrZrNrs@@  26"(X~Sj>B.AFAFB*6B*H"F"4 = 6B ( #-#J8v8"i'6i'V vrZ