J-jdZddlmZmZmZddlZddlZddl m Z ddl m Z ddlmZ[[[ddZdd ZGd d eZGd d eZGddeZGddeZGddeZGddeZy)zLA collection of variable boundaries (AKA box constraints) handling classes. )absolute_importdivisionprint_functionN)utils)rglen)#BoxConstraintsLinQuadTransformationcdD] tdk(r|r td}d<tjr!t fdt Dr|r td}d<|tfdt DstdS#t$r|r td}g<YwxYw)zreturn ``[lower_bounds, upper_bounds]`` such that each of them is either a nonempty `list` or `None`. `copy` only makes a shallow copy. On input, `bounds` must be a `list` of length 2. rrrFNc3nK|],}|duxstj| .ywN)npisfinite.0jboundsis b/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/boundary_handler.py z#normalize_bounds..!sB,/-q ! $EBKKq ! ,E(EE-s25c3\K|]#}|dztjzk(%yw)N)rinfrs rrz#normalize_bounds..(s4)G5E*01"q2669I)I5Es),zOlower/upper is +inf/-inf and therefore no finite feasible solution is available) lenlist TypeError_utilsis_allrany ValueError)rcopyrs` @rnormalize_boundsr# s $6!9~"!&\F D q zz&)$,/"6!9-,/)/fF1I !9 S)G5:6!95E)G&GUV V+. M! $f F1I  $s%B11!CCc||g}dtj gdtjgfD]_\}}|||r t|}d}|g||<!t||D].}||| ||rt||||<d||<||||<0a|S)zXreplace any None by inf or -inf. This code was never tested and is not in use. rrF)rrrr)rr"copy_iibvalrs r none_to_infr(.s D\FL1bff+.C ": fF2J vbz"Abz!}$":!%fRj!1F2J!&F2J #r 1 #/ Mc"eZdZdZdZdZdZy)BoundDomainTransformarcreate a `callable` with unbounded domain from a function with bounded domain, for example an objective or constraints function. The new "unbounded" `callable` maps ``x`` to ``function(self.transform(x))``, first "projecting" the input (e.g., candidate solutions) into the bounded domain with `transform` before to evaluate the result on the original function. The "projection" is smooth and differentiable, namely coordinate-wise piecewise linear or quadratic. The "projection" is not idempotent. Bounds are passed as ``boundaries = [lower_bounds, upper_bounds]`` where each ``*_bounds`` can be `None`, or a scalar, or an iterable (a vector) whose values can be `None` too. If the iterable has fewer values than the solutions, the last value is recycled, if it has more values, trailing values are ignored. For example, ``boundaries = [None, [0, 0, None]]`` means no lower bounds and an upper bound of zero for the first two variables. Example: >>> import cma >>> fun = cma.boundary_handler.BoundDomainTransform( ... cma.ff.sphere, # is composed with fun.transform into fun ... [[0.02, 0.01], None]) # boundaries for the "original" problem >>> x, es = cma.fmin2(fun, 3 * [0.5], 0.5, {'verbose':-9}) >>> assert all(x - 1e-4 < [-0.03, -0.04, -0.04]) # x is in the unbounded domain >>> print("solution in the original (bounded) domain = {}" ... .format(fun.transform(es.result.xfavorite))) solution in the original (bounded) domain = [0.02 0.01 0.01] The original function can be accessed and called via the attribute ``function`` like ``fun.function(...)``. For code simplicity, attributes of ``function`` are "inherited" to ``fun``. Details: the resulting function has a repetitive landscape with a period slightly larger than twice the boundary interval. The ``BoundDomainTransform(function,...)`` instance emulates the original function on attribute access by calling ``__getattr__``. To access shadowed attributes or for debugging, replace ``.attrname`` with ``.function.attrname``. ch||_t||_|jj|_yzDreturn a callable that evaluates `function` only within `boundaries`N)functionBoundTransformboundary_handler transformselfr. boundariess r__init__zBoundDomainTransform.__init__ns)  .z :..88r)cL|j|j|g|i|Sr r.r1r3xargskwargss r__call__zBoundDomainTransform.__call__s&t}}T^^A.@@@@r)c.t|j|Szreturn ``getattr(self.function, name)`` when ``not hasattr(self, name)``. This emulates the `function` interface, kinda like blind inheritance. getattrr.r3names r __getattr__z BoundDomainTransform.__getattr__u t}}d++r)N)__name__ __module__ __qualname____doc__r5r<rDr)rr+r+Cs)T9 A,r)r+c(eZdZdZdZdZdZdZy)_BoundDomainPenaltyzN[WIP early] function wrapper for penalty boundary handler, looks kinda complexch||_t||_|jj|_yr-)r. BoundPenaltyr0repairr1r2s rr5z_BoundDomainPenalty.__init__~s)  ,Z 8..55r)cL|j|j|g|i|Sr r7r8s rr<z_BoundDomainPenalty.__call__r=r)ct)z&needs the mean and the fitness values?NotImplementedError)r3s rcallbackz_BoundDomainPenalty.callbacks!!r)c.t|j|Sr?r@rBs rrDz_BoundDomainPenalty.__getattr__rEr)N)rFrGrHrIr5r<rTrDrJr)rrLrL|sX6 A",r)rLcveZdZdZdZ dZddZdZdZddZ ddZ d Z d Z dd Z d Zdd ZdZdZddZy)BoundaryHandlerBasezquick hack versatile base class. To guaranty that modifications of the attribute `bounds` after this instance was already used are effective, the class attribute ``_bounds_dict`` must be reset like ``_bounds_dict = {}``. Fc&tj|_|ddgfvrd|_i|_ yt|tt frt |dk7r tdtt|ztt |d|_i|_ y)a`bounds` can be ``None`` or ``[lb, ub]`` where ``lb`` and ``ub`` are either ``None`` or a vector (which can have ``None`` entries). On return, the ``bounds`` attribute of ``self`` are the bounds in a normalized form. To compute bounds for any dimension, the last entry of bounds is then recycled for variables with ``indices >= len(bounds[i]) for i in (0,1)``. NrJzbounds must be None, empty, or a list of length 2 where each element may be a scalar, list, array, or None; type(bounds) was: %sFr") rWuse_cached_valuesr isinstancetuplerrr!strtyper# _bounds_dict)r3rs rr5zBoundaryHandlerBase.__init__s"5!F!F dB^ #DK 4fudm4F q8H 57:4<7HIJJ+4.set_boundssQF? )E )?66#;ZZ_Q'O+"CF(66#;SU!34VVBJJsOA$67!;=>I__UI6F6{SX%,3v;'Vs3x'iibhhs6{SX/ET&R ST 3KAE MV3bjjBFF6RU;DW6XX XK!'DKK  "D r)rr upperlower) has_boundsrerfrmod)r3rnatrprqrorlrs` ` r"amend_bounds_for_integer_variablesz6BoundaryHandlerBase.amend_bounds_for_integer_variablesss doo&7  #*(1, E??e7A__UI6F ubffVQ/25 G r)cTtj|drdSt|dgzS)zreturn penalty or list of penalties, by default zero(s). This interface seems too specifically tailored to the derived BoundPenalty class, it should maybe change. r)risscalarr)r3 solutionsr:r;s rr<zBoundaryHandlerBase.__call__s)kk)A,/sKS^se5KKr)c|S)z;end-iteration callback of boundary handler (abstract/empty)rJ)r3r:r;s rupdatezBoundaryHandlerBase.updates r)c |}|j|SdD]}|j|t|D]}t|t|j|dz g}|j|| > >Vr26q !fQi&7"6*IB}aEW,aEW,FQJE &57?RVV+C! +r)c |jydD]}|j|t|D]}|t|j|dz k(r@|j||,dd|z z|j||ztjk(rt |t|j|dz g}|j|||dk(r|||j||ks|dk(s|||j||kDsyy)aIreturn `True` if `x` is in bounds. >>> import numpy as np >>> import cma >>> b = cma.boundary_handler.BoundaryHandlerBase(bounds=[[-0.5], 0.2]) >>> for n in [2, 4, 9]: ... x = np.random.randn(n) ... assert (all(-0.5 <= x) and all(0.2 >= x)) is b.is_in_bounds(x) Tr rrrF)rrrrrr)r3r9r&rrms r is_in_boundsz BoundaryHandlerBase.is_in_bounds.s  ;; B{{2&1XDKKO,q00 B*2q2vR);;rvvE1c$++b/2Q678;;r?3'/1W1 B(>> import numpy as np >>> import cma >>> b = cma.boundary_handler.BoundaryHandlerBase(bounds=[[0.1], 0.2]) >>> assert all(0.1 <= b.into_bounds(np.random.randn(22))) >>> assert all(0.2 >= b.into_bounds(np.random.randn(11))) >>> b = cma.boundary_handler.BoundaryHandlerBase(bounds=[[-0.1], np.inf]) >>> assert all(-0.1 <= b.into_bounds(np.random.randn(22))) >>> b = cma.boundary_handler.BoundaryHandlerBase(bounds=[[-0.1], [None]]) >>> assert all(-0.1 <= b.into_bounds(np.random.randn(22))) >>> b = cma.boundary_handler.BoundaryHandlerBase(bounds=[-np.inf, 0.1]) >>> assert all(0.1 >= b.into_bounds(np.random.randn(22))) r rrrTrZF)rrrrrrr)r3r9r"r&rrms r into_boundszBoundaryHandlerBase.into_boundsLs?( ;; HB{{2&1XDKKO,q00++b/!,4R.4;;r?1+==G1c$++b/2Q678;;r?3'/1W1R)=!=1W1R)=!=.A D{{2s+!$r)c ||jgSg}dD]}|j|t|D]}}t|t|j|dz g}|j||<|dk(r|||j||ks|dk(s_|||j||kDsx||gz }t |S)zreturn index list of out-of-bound values in `x`. ``if bounds.idx_out_of_bounds`` evaluates to `True` if and only if `x` is out of bounds. r rr)rrrrsorted)r3r9idxsr&rrms ridx_out_of_boundsz%BoundaryHandlerBase.idx_out_of_boundsvs ;; IB{{2&1X1c$++b/2Q678;;r?3'/1W1 B(!*CKKOCDKKO0Dq0H(I$JK JJ (,q A   r)Nc h| |j}|sddggStt|d}dD]}|| dg||<dDcgc]}t ||}}|d|dk7r;d|vr7d|dd|ddfvr%t j dj||g} tt|D]C}|j|dt||ddz f|dt||ddz fgE |S#t$rYwxYwcc}w#ttf$r td wxYw) zreturn boundaries in format ``[[lb0, ub0], [lb1, ub1], ...]``, as used by ``BoxConstraints...`` class. Use by default ``bounds = self.bounds``. NFrZr rrrzlower and upper bounds do not have the same length or length one or `None` as last element (the last element is always recycled). Lengths are {0} = [len(b) for b in bounds={1}])zLboundaries must be provided in the form [scalar_of_vector, scalar_or_vector])rAttributeErrorr#rr _warningswarnrrrerrr IndexErrorprint)r3rrlrs rto_dim_times_twoz$BoundaryHandlerBase.to_dim_times_twos{ > 4L> !!$v,U;Aay !Fq &, ,VS^V , Q41Q4T)rr )rFrGrHrIr[r5rwr<r}rOrrfrrtrrrrrrJr)rrWrWs] =48!HFL& J2(*<(T* "r)rWc*eZdZdZdfd ZdZxZS) BoundNonez no boundariescD| ttt|dyr )r!superrr5r3r __class__s rr5zBoundNone.__init__s  ,  i'-r)cy)NTrJr3r9s rrzBoundNone.is_in_boundssr)r )rFrGrHrIr5r __classcell__rs@rrrs. r)rc:eZdZdZdfd ZddZdZddZxZS)r/aHandle boundaries by a smooth, piecewise linear and quadratic transformation into the feasible domain. >>> import numpy as np >>> import cma >>> from cma.boundary_handler import BoundTransform >>> from cma import fitness_transformations as ft >>> veq = cma.utilities.math.Mh.vequals_approximately >>> b = BoundTransform([0, None]) >>> assert b.bounds == [[0], None] >>> assert veq(b.repair([-0.1, 0, 1, 1.2]), np.array([0.0125, 0.0125, 1, 1.2])), b.repair([-0.1, 0, 1, 1.2]) >>> assert b.is_in_bounds([0, 0.5, 1]) >>> assert veq(b.transform([-1, 0, 1, 2]), [0.9, 0.0125, 1, 2 ]), b.transform([-1, 0, 1, 2]) >>> bounded_sphere = ft.ComposedFunction([ ... cma.ff.sphere, ... BoundTransform([[], 5 * [-1] + [np.inf]]).transform ... ]) >>> o1 = cma.fmin(bounded_sphere, 6 * [-2], 0.5) # doctest: +ELLIPSIS (4_w,9)-aCMA-ES (mu_w=2.8,w_1=49%) in dimension 6 (seed=... >>> o2 = cma.fmin(cma.ff.sphere, 6 * [-2], 0.5, options={ ... 'BoundaryHandler': cma.boundary_handler.BoundTransform, ... 'bounds': [[], 5 * [-1] + [np.inf]] }) # doctest: +ELLIPSIS (4_w,9)-aCMA-ES (mu_w=2.8,w_1=49%) in dimension 6 (seed=... >>> assert o1[1] < 5 + 1e-8 and o2[1] < 5 + 1e-8 >>> b = BoundTransform([-np.random.rand(120), np.random.rand(120)]) >>> for i in range(0, 100, 9): ... x = (-i-1) * np.random.rand(120) + i * np.random.randn(120) ... x_to_b = b.repair(x) ... x2 = b.inverse(x_to_b) ... x2_to_b = b.repair(x2) ... x3 = b.inverse(x2_to_b) ... x3_to_b = b.repair(x3) ... assert veq(x_to_b, x2_to_b) ... assert veq(x2, x3) ... assert veq(x2_to_b, x3_to_b) >>> for _ in range(5): ... lb = np.random.randn(4) ... ub = lb + 1e-7 + np.random.rand(4) ... b = BoundTransform([lb, ub]) ... for x in [np.random.randn(4) / np.sqrt(np.random.rand(4)) for _ in range(22)]: ... assert all(lb <= b.transform(x)), (lb, ub, b.__dict__) ... assert all(b.transform(x) <= ub), (lb, ub, b.__dict__) Details: this class uses ``class BoxConstraintsLinQuadTransformation`` cjtt| |t|j ||_y)zArgument bounds can be `None` or ``bounds[0]`` and ``bounds[1]`` are lower and upper domain boundaries, each is either `None` or a scalar or a list or array of appropriate size. N)rr/r5r r bounds_tfrs rr5zBoundTransform.__init__s, nd,V4#9#';;q>#9Hzz$..D122r)c$|j|Sr )rOrs rr1zBoundTransform.transforms{{1~r)c|j|jd|jd|Stj|jj ||S)z=inverse transform of ``x`` from the bounded domain. rr)rrrrr)r3r9rs rrzBoundTransform.inverse sN ;; 4;;q>#9#';;q>#9Hzz$..00ODEEr)r r) rFrGrHrIr5rOr1rrrs@rr/r/s-\\3Fr)r/c>eZdZdZdfd ZddZdZdZdZxZ S) rNaCompute a bound penalty and update coordinate-wise penalty weights. An instance must be updated each iteration using the `update` method. Details: - The penalty computes like ``sum(w[i] * (x[i]-xfeas[i])**2)``, where ``xfeas`` is the closest feasible (in-bounds) solution from ``x``. The weight ``w[i]`` should be updated during each iteration using the update method. Example how this boundary handler is used with `cma.fmin` via the options (`CMAOptions`) of the class `cma.CMAEvolutionStrategy`: >>> import cma >>> res = cma.fmin(cma.ff.elli, 6 * [0.9], 0.1, ... {'BoundaryHandler': cma.BoundPenalty, ... 'bounds': [-1, 1], ... 'tolflatfitness': 10, ... 'fixed_variables': {0: 0.012, 2:0.234} ... }) # doctest: +ELLIPSIS (4_w,8)-aCMA-ES (mu_w=2.6,w_1=52%) in dimension 4 (seed=... >>> if res[1] >= 13.76: print(res) # should never happen Reference: Hansen et al 2009, A Method for Handling Uncertainty... IEEE TEC, with addendum, see https://ieeexplore.ieee.org/abstract/document/4634579 https://hal.inria.fr/inria-00276216/file/TEC2008.pdf **todo**: implement a more generic interface, where this becomes a fitness wrapper which adds the desired penalty and the `update` method is used as callback argument for `fmin` like:: f = cma.BoundPenalty(cma.ff.elli, bounds=[-1, 1]) res = cma.fmin(f, 6 * [1], callback=f.update) where callback functions should receive the same arguments as `tell`, namely an `CMAEvolutionStrategy` instance, an array of the current solutions and their respective f-values. Such change is relatively involved. Consider also that bounds are related with the geno- to phenotype transformation. cVtt| |d|_d|_g|_y)zArgument bounds can be `None` or ``bounds[0]`` and ``bounds[1]`` are lower and upper domain boundaries, each is either `None` or a scalar or a `list` or `np.array` of appropriate size. rFN)rrNr5gammaweights_initializedhistrs rr5zBoundPenalty.__init__?s* lD*62 #(  r)c|}|jrJ|j}|rtj|d}|dtj|dr't |D]}t |d||f||<nNt |D]@}t|t|ddz g}|d|(t |d|||f||<B|dtj|dr(t |D]}t|d||f||<|St |D]@}t|t|ddz f}|d|(t|d|||f||<B|S)zssets out-of-bounds components of ``x`` on the bounds. TODO: unify with BoundaryHandlerBase.repair TrZrr) rtrrrrzrrerr)r3r9rr"rrrs rrOzBoundPenalty.repairMsw ?? [[FHHQT*ay$;;vay)"1X"F1Iqt#45!&#1XCq NQ$6 78!!9Q<3#&q ! ad';##BBCc"gM N,s1v44 JJE sAD**EEct)zcounts for each coordinate the number of feasible values in ``solutions`` and returns an `np.array` of length ``len(solutions[0])`` with the ratios. rR)r3r{s rfeasible_ratiozBoundPenalty.feasible_ratios "!r)c  |j|jd|jd|S|j}ddkr|jdztjtj |j r||j gznVtj |j dr |j n(t|Dcgc]}|j ||c}z}n&|jdz|jjz}|j|jj|j|jj|jz |dzz }t|}dt!|z}|d|zdz||dzz } | tj|z } tj"| r"| dkDr|j$j'd| n\| tj(k(rHt!|j$dkDr0|j$j'dt+|j$n t!|j$dd|z|j,z zkDr|j$j/tj0|j$} t3d|j4j6j8d z |z } t!|j$dk(r t;d |j=rC|j>r|j@dk(r(tj|d| zgz|_!d |_|j>rtjtE|dt+d|dz|j4j6j8z zz } ddkr|xjBtjF| dkDtjH| dz zd z | zzc_!|jB|jBd | zkDxxtjFd| zzcc<nddkr_| dkDj=rL|jB| dkDxxdt3d|j4j6j8d z |z zzcc<n|j.} |jK| }|xjBtjFtj*|dgzd|z gdt3d|j4j6j8dz |z zzc_!|xjL|j>rtO|jBn|dgzz c_&|Scc}w)aupdates the weights for computing a boundary penalty. Arguments ========= ``function_values``: all function values of recent population of solutions ``es``: `CMAEvolutionStrategy` object instance, in particular mean and variances and the methods from the attribute `gp` of type `GenoPheno` are used. rr rYrg$@a-wrongful initialization, no feasible solution sampled. Reasons can be mistakenly set bounds (lower bound not smaller than upper bound) or a too large initial sigma0 or... See description of argument func in help(cma.fmin) or an example handling infeasible solutions in help(cma.CMAEvolutionStrategy). Tg@gUUUUUUտg?g333333?)axis g?)(rNsigmarrrzCrsm variancesmeanrrrOrrrrrrrrepopsizepopmedianrspweightsmueffr!r r countiterrrkexptanhr more_to_writer)r3function_valuesesrrvarisdmeanfvals_lr'dfitdampedistr{rs rr}zBoundPenalty.updates? ;; 4;;q>#9#';;q>#9K DD 6HHaK"((RTT9J1v:,.KKQ,@BDD9>q$BARTT!WQZ$B#EEEHHaK"%%//1E255::dkk"%%++bgg2F&GHHESVJV' U^AFaK 5q>1BGGEN" ;;s a II  Q $ BFF]s499~1 II  QDII /  tyy>B!a%2::!55 5 IIMMOyy#1beemm))C/!34 tyy>Q UV V 99; 8 8BLLAQ>Q5Q.R*RRSE1u bffeai2775193E%E%JKTQQ  4::D01RVVG_d5JJ1QEAI??, 519%c!RUU]]5H5H35NQR5R.S)SS% FF '' 2 bffRVVQ!WcAg,>Q%GH#aQSQVQVQ^Q^QdQdgiQilmQmJnnn  0H0HD,aSVRWiW y%CsU0 r r) rFrGrHrIr5rOr<rr}rrs@rrNrNs%)T D!5J"Sr)rNr)rI __future__rrrwarningsrnumpyr utilitiesrrutilities.utilsrtransformationsr r#r(objectr+rLrWrr/rNrJr)rrs@@&"@X~ D*7,67,r,&,&k&kZ #LF(LF\\&\r)