B ú‹d¶vã@sdZddlZddlZddlZddlZddlmZddlZddl m Z ddl m Z m Z mZmZmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z d d d gZ!e e eeed œZ"Gd d„deƒZ#dd„Z$ddd „Z%dd„Z&ddd „Z'ddd„Z(ddd„Z)Gdd „d ƒZ*dS)a° Contains the dynamic nested sampler class :class:`DynamicSampler` used to dynamically allocate nested samples. Note that :class:`DynamicSampler` implicitly wraps a sampler from :mod:`~dynesty.nestedsamplers`. Also contains the weight function :meth:`weight_function` and stopping function :meth:`stopping_function`. These are used by default within :class:`DynamicSampler` if corresponding functions are not provided by the user. éN)ÚEnum)Ú logsumexpé)ÚUnitCubeSamplerÚSingleEllipsoidSamplerÚMultiEllipsoidSamplerÚRadFriendsSamplerÚSupFriendsSampler)ÚResults) Úget_seed_sequenceÚget_print_funcÚ _kld_errorÚcompute_integralsÚIteratorResultÚIteratorResultShortÚget_enlarge_bootstrapÚ RunRecordÚget_neff_from_logwtÚ DelayTimerÚ save_samplerÚrestore_samplerÚ _LOWL_VALÚDynamicSamplerÚweight_functionÚstopping_function)ÚnoneZsingleÚmultiZballsZcubesc@s4eZdZdZdZdZdZdZdZdZ dZ d Z d Z d S) ÚDynamicSamplerStatesEnumú réééééééé N) Ú__name__Ú __module__Ú __qualname__Ú__doc__ÚINITÚLIVEPOINTSINITÚINBASEÚ BASE_DONEÚINBATCHÚ BATCH_DONEÚ INBASEADDLIVEÚINBATCHADDLIVEÚRUN_DONE©r4r4úc/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/dynesty/dynamicsampler.pyr-src CsÞ|j}|j}|j}|j}|j}| ¡dkrLt d¡t  t |ƒ¡t |ƒ}nj|d|d}t  |d|¡}t  |¡} t | ||gd| | gd} | t |¡} | t | ƒ8} t | ¡}t ||d¡} | t | ¡} || fS)zj Derive evidence and posterior weights. return two arrays, evidence weights and posterior weights rzŒThe calculation of weights is seeing same logz values associated with all the samples. It may mean somethings is wrong with your likelihood.éÿÿÿÿ)ZaxisÚb)ÚloglÚlogzÚlogvolÚlogwtÚ samples_nÚptpÚwarningsÚwarnÚnpÚonesÚlenZ logaddexpZ ones_likerÚlogÚexpÚsum) Úresultsr8r9r:r;r<ÚzweightZ logz_remainZlogz_totZlzonesZlogzinZ logzweightÚpweightr4r4r5Úcompute_weights;s*     rIFcCs°|dkr i}| dd¡}d|kr,dks>ntd|›dƒ‚| dd¡}d|kr^dkspntd |›dƒ‚| d d ¡}|d kr”td |›dƒ‚t|ƒ\}}d||||}t|ƒ} t ||t |¡k¡d } | d || d|f} |j} | d | d kr(| d | d | d | d g} | d d kr^tj } | t | d | d | d ƒ} n| | d | | d } } | d | d krtj} |r¨| | f|||ffS| | fS)a The default weight function utilized by :class:`DynamicSampler`. Zipped parameters are passed to the function via :data:`args`. Assigns each point a weight based on a weighted average of the posterior and evidence information content:: weight = pfrac * pweight + (1. - pfrac) * zweight where `pfrac` is the fractional importance placed on the posterior, the evidence weight `zweight` is based on the estimated remaining posterior mass, and the posterior weight `pweight` is the sample's importance weight. Returns a set of log-likelihood bounds set by the earliest/latest samples where `weight > maxfrac * max(weight)`, with additional left/right padding based on `pad`. Parameters ---------- results : :class:`Results` instance :class:`Results` instance. args : dictionary of keyword arguments, optional Arguments used to set the log-likelihood bounds used for sampling, as described above. Default values are `pfrac = 0.8`, `maxfrac = 0.8`, and `pad = 1`. return_weights : bool, optional Whether to return the individual weights (and their components) used to compute the log-likelihood bounds. Default is `False`. Returns ------- logl_bounds : tuple with shape (2,) Log-likelihood bounds `(logl_min, logl_max)` determined by the weights. weights : tuple with shape (3,), optional The individual weights `(pweight, zweight, weight)` used to determine `logl_bounds`. NÚpfracgš™™™™™é?ggð?zThe provided `pfrac` z is not between 0. and 1.ÚmaxfraczThe provided `maxfrac` Úpadrrz`lpad` z is less than zero.r6) ÚgetÚ ValueErrorrIrBr@ÚnonzeroÚmaxr8ÚinfÚmin)rFÚargsZreturn_weightsrJrKZlpadrGrHÚweightZnsampsZboundsr8Úlogl_minÚlogl_maxr4r4r5r_s<,      cCsÄ|dkr||dkrd}q²|dkr(d|}q²|dkr>d||}q²|dkrPd |}q²|d krbd |}q²tj}t d |›d ¡n6t|tƒrŒ|}n&t|tƒr¤|d|}ntd|›ƒ‚|dkrÀtj}|S)zF Get the update_interval divided by the number of live points NZunifgø?Zrwalkg333333Ã?ÚslicegÍÌÌÌÌÌì?Úrsliceg@Zhsliceg9@z6No update_interval set with unknown sampling method: 'z'. Defaulting to no updates.gð?zStrange update_interval value r)r@rQr>r?Ú isinstanceÚfloatÚintÚ RuntimeError)Úupdate_intervalÚsampleÚboundÚndimÚnliveÚslicesÚwalksZupdate_interval_fracr4r4r5Ú_get_update_interval_ratio¸s,     rdcs|dkr i}|dkrt}| dd¡}d|kr8dksJntd|›dƒ‚| dd¡}|dkr||dkr|td |›d |›d ƒ‚| d d ¡}|dkr²|dkr²td|›dd|›ƒ‚| dd¡}|dkrÖtd|›dƒ‚|dkrð|dkrðt d¡| dd¡‰ˆdkrtdˆ›dƒ‚| dd¡‰|dkr´‡fdd „t|ƒDƒ} ‡fd!d „t|ƒDƒ} ‡fd"d „t|ƒDƒ} t||ƒ} t| | | | ƒ}t|t |ƒƒ} t   d#d „| Dƒ¡}t   |¡}n ˆj d$}||}tˆjƒ}||}||d||}|r|dk|||ffS|dkSdS)%a© The default stopping function utilized by :class:`DynamicSampler`. Zipped parameters are passed to the function via :data:`args`. Assigns the run a stopping value based on a weighted average of the stopping values for the posterior and evidence:: stop = pfrac * stop_post + (1.- pfrac) * stop_evid The evidence stopping value is based on the estimated evidence error (i.e. standard deviation) relative to a given threshold:: stop_evid = evid_std / evid_thresh The posterior stopping value is based on the estimated effective number of samples. stop_post = target_n_effective / n_effective Estimates of the mean and standard deviation are computed using `n_mc` realizations of the input using a provided `'error'` keyword (either `'jitter'` or `'resample'`, which call related functions :meth:`jitter_run` and :meth:`resample_run` in :mod:`dynesty.utils`, respectively. Returns the boolean `stop <= 1`. If `True`, the :class:`DynamicSampler` will stop adding new samples to our results. Parameters ---------- results : :class:`Results` instance :class:`Results` instance. args : dictionary of keyword arguments, optional Arguments used to set the stopping values. Default values are `pfrac = 1.0`, `evid_thresh = 0.1`, `target_n_effective = 10000`, `n_mc = 0`, `error = 'jitter'`, and `approx = True`. rstate : `~numpy.random.Generator`, optional `~numpy.random.Generator` instance. M : `map` function, optional An alias to a `map`-like function. This allows users to pass functions from pools (e.g., `pool.map`) to compute realizations in parallel. By default the standard `map` function is used. return_vals : bool, optional Whether to return the stopping value (and its components). Default is `False`. Returns ------- stop_flag : bool Boolean flag indicating whether we have passed the desired stopping criteria. stop_vals : tuple of shape (3,), optional The individual stopping values `(stop_post, stop_evid, stop)` used to determine the stopping criteria. NrJgð?gzThe provided `pfrac` z is not between 0. and 1.Ú evid_threshgš™™™™™¹?zThe provided `evid_thresh` z, is not non-negative even though `pfrac` is Ú.Útarget_n_effectivei'z"The provided `target_n_effective` rz+is not non-negative even though `pfrac` is Ún_mcrzThe number of realizations z" must be greater or equal to zero.éz`Using a small number of realizations might result in excessively noisy stopping value estimates.ÚerrorÚjitter>rkÚresamplezThe chosen `'error'` option z is not valid.ÚapproxTrcsg|]}ˆ‘qSr4r4)Ú.0Úi)rFr4r5ú =sz%stopping_function..csg|]}ˆ‘qSr4r4)rnro)rjr4r5rp>scsg|]}ˆ‘qSr4r4)rnro)rmr4r5rp?scSsg|]}|djd‘qS)rr6)r9)rnÚresr4r4r5rpCsr6)ÚmaprMrNr>r?Úranger ÚzipÚlistr r@ÚarrayZstdÚlogzerrrr;)rFrSÚrstateÚMÚ return_valsrJrergrhZrlistZ error_listZ approx_listZseedsÚoutputsZlnz_arrZlnz_stdZ stop_evidÚ n_effectiveZ stop_postÚstopr4)rmrjrFr5rØsVB              c  Cs€d} d} |dkr¬d} t|t|ddƒƒ} t ||f¡} t ||f¡}t |¡}d}g}d}xè|d7}|j||fd}|rŽ||t |¡ƒ}nt|t |¡ƒ}t t|ƒ¡}| t |¡¡}|rÔt dd„|Dƒ¡}t d d„|Dƒ¡}| |7} t  |¡}|}t  |¡}t  ||@¡r$t d ƒ‚t ||<| ¡}|dkrÈt|||ƒ}|dksZt‚t |¡dd|…}||||||…<||| |||…<||||||…<|rÀ| ||¡||7}|| krj||}|dkr\t |¡dd|…}t|ƒ|ks t‚||||||…<||| |||…<||||||…<|r\| ||¡t |¡ } P|| kr`|dkrŽtd | ›d ƒ‚q`t d | ›d | ›d¡q`Wnœ|dd…\} }}|rÌ|d}t |¡}xXt|ƒD]L\}}t  |¡sàt |¡dkrt ||<nt d ||| |||¡ƒ‚qàWt |t k¡rHt dƒ‚t |¡dkrdt dt¡|snd}| |||f| | fS)a« Initialize the first set of live points before starting the sampling Parameters ---------- live_points: tuple of arrays or None This can be either none or tuple of 3 arrays (u, v, logl) or tuple of 4 arrays (u, v, logl, blobs), i.e. points location in cube coordinates, point slocation in original coordinates, logl values and optionally blobs associated prior_transform: function log_likelihood: function M: function The function supporting parallel calls like M(func, list) nlive: int Number of live-points npdim: int Number of dimensions rstate: :class: numpy.random.RandomGenerator blob: bool If true we also keep track of blobs returned by likelihood use_pool_ptform: bool or None The flag to perform prior transform using multiprocessing pool or not Returns ------- (live_u, live_v, live_logl, blobs), logvol_init, ncalls : tuple The first tuple consist of: live_u Unit cube coordinates of points live_v Original coordinates. live_logl log-likelihood values of points blobs - Array of blobs associated with logl calls (or None) The other arguments are logvol_init Log(volume) associated with returned points. It will be zero, if all the log(l) values were finite ncalls Integer number of function calls rNièré )ÚsizecSsg|] }|j‘qSr4)Úblob)rnÚ_r4r4r5rp²sz+_initialize_live_points..cSsg|] }|j‘qSr4)Úval)rnrr4r4r5rp³sz,The log-likelihood of live point is invalid.zAfter z† attempts, we cound not find a single point that have a valid log-likelihood! Please check your prior transform and/or log-likelihood.z& attempts, we cound not find at least zS points that have a valid log-likelihood! The initial sampling is very inefficient!r zNThe log-likelihood ({0}) of live point {1} located at u={2} v={3} is invalid.zr?Ú enumerateÚsignÚformatÚallr=ÚRuntimeWarning)Ú live_pointsÚprior_transformÚ loglikelihoodryraÚnpdimrxr€Úuse_pool_ptformÚ logvol_initZncallsZ n_attemptsZ min_npointsÚlive_uÚlive_vÚ live_loglZngoodsÚ live_blobsZiattemptZ cur_live_uZ cur_live_vZ cur_live_loglZcur_live_blobsZfiniteZ not_finiteZ neg_infiniteZ cur_ngoodZnextraZcur_indror8r4r4r5Ú_initialize_live_pointsWs˜8             ršc(Csžd}d}t |jd¡}t |jd¡}t |jd¡} t |jd¡} t |jd¡} t |jd¡} g} t|j|j|j|j|j|j ||j |j |j |j |j|j|j|jd}||_|jj|_|d kr"t | | d t |¡k¡d}t|ƒdkr|d }n t| ƒd }tj | |}}n|\}}t | |k¡}|rtd |j|j|j||j|j |j|jd \\}}}}}}tj|td }tj|td }tj|td }||7}xPt |ƒD]D}|  !t"| d ||||||d |||j#dd|j$d ¡q°W| %|¡nØt | |k¡d}t|ƒdkrDt&d|›d|›d|  '¡›ƒ‚t|ƒ|kr¸t| ƒ|krpt (t| ƒ¡}n t (|d |d |d d ¡}|ddkr°| |dd }ntj }| |d}| |}t )|| '¡¡} | |  *¡} | dk *¡}!|j j+|t,||!ƒ| dd}"t|"ƒ}#|#d krTt&dd|›dd|#›d|!›d| ›ƒ‚||"d d …f -¡}||"d d …f -¡}| |" -¡}| |" -¡}|#|_.||_/||_0||_1||_2||_3| %|¡t 4||jf¡}t 4||j5d f¡}t 4|¡}tj|td }tj|td }tj4|td }|jr(g}nd }x°t |ƒD]¤}| 6|¡}$|$\||<||<||<||<|jr~|$dj}%| !|%¡nd }%|||7}|  !t"| d |||||||||||j#|||||j$d ¡q6W||7}||_.||_/||_0||_1||_7||_3||_8|r||_9|tj kr0d}&nt :t ;| |¡¡d }&x,|j <¡D]}'|j|'d |&…|j|'<qTWt= |d|¡|_>| |_?|||||fS)a This is a utility method that construct a new internal sampler that will sample one batch. Since the setting up requires us coming up with a set of of starting live points we also prepare the first list points that will be yielded by the "master" sampler (but those are yielded just for printing). This method should not modify the parent sampler at all other than using the parent's random number generator Parameters ---------- main_sampler: DynamicNestedSampler The parent sampler that we'll use to initialize a new sampler nlive_new: integer The number of live-points in the new sampler update_interval : int Only update the bounding distribution every `update_interval`-th likelihood call. Note that here it must be integer logl_bounds: tuple Tuple of bounds in loglikelihood for the batch save_bounds: bool If true bounds will be preserved Returns ------- batch_sampler: Sampler The sampler that will actually execute the batch. It will also have a first_points attribute with the list of IteratorResultShorts ncall: integer Number of likelihood calls throughout niter: integer Number of iterations logl_min: float actually used logl_min as we may modify logl_bound logl_max: float actually used logl_max rÚuÚvr8r:Úscaler€)ÚncdimÚkwargsr€Nr6r)rar“rxr€r”)Údtype) ÚworstÚustarÚvstarÚloglstarÚncÚworst_itÚboundidxÚ bounditerÚeffz`Could not find live points in the required logl interval. Please report! Diagnostics. logl_min: z logl_bounds: z saved_loglmax: F)rÚpÚreplacezBOnly one live point is selected Please report the error on github!zDiagnostics nlive_new: rz cur_nlive: zn_pos_weight: zcur_wt: rgð?)@r@rvÚ saved_runÚ _SAMPLERSÚboundingr’r‘r“Ú live_initÚmethodÚ first_updaterxÚ queue_sizeÚpoolÚuse_poolržrŸr€Ú save_boundsÚsamplerZlogl_first_updaterOrCrBrQrŽršryr”rƒr[rArsÚappendrÚitr©Zupdate_bound_if_neededr\rPZarangerDrEÚchoicerRÚcopyrar–r—r˜rr™ÚemptyÚshapeZ _new_pointÚ live_boundÚlive_itr•ZargminÚabsÚkeysÚmathZdlvÚ first_points)(Z main_samplerÚ nlive_newr]Ú logl_boundsrµÚncallÚniterZsaved_uZsaved_vZ saved_loglZ saved_logvolZ saved_scaleZ saved_blobsrÂÚ batch_samplerZ logl_max_posrUrVZpselr–r—r˜r™Zlogvol0Ú init_ncallsr½r¾Zlive_ncroZsubset0Z live_scaleZ cur_log_uniwtZ cur_uniwtZ n_pos_weightZsubsetZ cur_nliveZnewptr€Zvol_idxÚkr4r4r5Ú_configure_batch_samplers 9          "         rÊc@sòeZdZdZdd„Zdd„Zdd„Zdd „Zed'd d „ƒZ d d„Z dd„Z e dd„ƒZ e dd„ƒZe dd„ƒZd d d d d ejdejd ddf dd„Zd(dd„Zdd„Zd d d dejejd d d d d d d d d d d dddd d dd d fd!d"„Zd)d%d&„Zd S)*ra/ A dynamic nested sampler that allocates live points adaptively during a single run according to a specified weight function until a specified stopping criteria is reached. Parameters ---------- loglikelihood : function Function returning ln(likelihood) given parameters as a 1-d `~numpy` array of length `ndim`. prior_transform : function Function transforming a sample from the a unit cube to the parameter space of interest according to the prior. npdim : int, optional Number of parameters accepted by `prior_transform`. bound : {`'none'`, `'single'`, `'multi'`, `'balls'`, `'cubes'`}, optional Method used to approximately bound the prior using the current set of live points. Conditions the sampling methods used to propose new live points. method : {`'unif'`, `'rwalk'`, `'slice'`, `'rslice'`, `'hslice'`}, optional Method used to sample uniformly within the likelihood constraint, conditioned on the provided bounds. update_interval : int Only update the bounding distribution every `update_interval`-th likelihood call. first_update : dict A dictionary containing parameters governing when the sampler should first update the bounding distribution from the unit cube to the one specified by the user. rstate : `~numpy.random.Generator` `~numpy.random.Generator` instance. queue_size: int Carry out likelihood evaluations in parallel by queueing up new live point proposals using (at most) this many threads/members. pool: pool Use this pool of workers to execute operations in parallel. use_pool : dict A dictionary containing flags indicating where the provided `pool` should be used to execute operations in parallel. ncdim: int Number of clustered dimensions nlive0: int Default number of live points to use kwargs : dict, optional A dictionary of additional parameters (described below). cCsÄ||_||_||_| |_| d¡p$d|_||_||_||_||_ d|_ ||_ t || d¡| d¡ƒ\|_ |_|j  dd¡|_|j  dd¡|_|j  d ¡|_|j  d ¡|_||_| |_| |_|jdkrÌt|_n| j|_| |_|  d d ¡|_|  d d ¡|_|  dd ¡|_|  dd ¡|_|  dd ¡|_d|_d|_d|_ g|_!d|_"d|_#| |_$t%j&|_'t(d d|_)t(d d|_*d|_+t,j- t,j-|_.|_/d|_0d|_1d|_2d|_3d|_4d|_5d|_6d|_7d|_8d|_9dS)Nr€FÚenlargeÚ bootstraprcérbr ÚciteZ update_funcr‘Tr’Z propose_pointZ update_boundÚ stop_functionrrgð?)Údynamic):r’r‘r“ržrMr€r®r°Úupdate_interval_ratior±r¶rŸrrËrÌrcrbrÎZ custom_updaterxr²r³rrryr´r”Z use_pool_loglZuse_pool_evolveZuse_pool_updateÚuse_pool_stopfnr¸ÚbatchrÅr_r©ÚbaseÚnlive0rr+Úinternal_staterr¬Úbase_runÚnew_runr@rQÚ new_logl_minÚ new_logl_maxr–r—r¾r½r˜r¯Ú nlive_initrÇÚcheckpoint_timerr™)Úselfr’r‘r“r_r°rÑr±rxr²r³r´ržrÕrŸr4r4r5Ú__init__Žsf   zDynamicSampler.__init__cCs||_d|_t|_dS)N)Ú__dict__r³rrry)rÝÚstater4r4r5Ú __setstate__ÝszDynamicSampler.__setstate__cCs|j ¡}|d=|d=|S)z#Get state information for pickling.r³ry)rßrº)rÝràr4r4r5Ú __getstate__âs zDynamicSampler.__getstate__cCst||ƒdS)z¦ Save the state of the dynamic sampler in a file Parameters ---------- fname: string Filename of the save file. N)r)rÝÚfnamer4r4r5Úsaveís zDynamicSampler.saveNcCs t||dS)aà Restore the dynamic sampler from a file. It is assumed that the file was created using .save() method of DynamicNestedSampler or as a result of checkpointing during run_nested() Parameters ---------- fname: string Filename of the save file. pool: object(optional) The multiprocessing pool-like object that supports map() calls that will be used in the restored object. )r³)r)rãr³r4r4r5ÚrestoreùszDynamicSampler.restorecCs^t|tƒsZt|tƒr|}n |dkr*|j}ntt d|¡ƒ‚tttt   ||¡t j ƒdƒƒ}|S)NzWeird update_interval value {}r) rYr[rZrÑr\ÚstrrrPrRr@ÚroundÚsysÚmaxsize)rÝr]raZcur_update_interval_ratior4r4r5Z__get_update_interval s  z$DynamicSampler.__get_update_intervalcCsZd|_d|_d|_g|_d|_d|_tdd|_tdd|_d|_ t j t j |_ |_ dS)zRe-initialize the sampler.rrgð?FT)rÐN)r¸rÓrÅr_r©rÔrr¬r×rØr@rQrÙrÚ)rÝr4r4r5Úresets  zDynamicSampler.resetc CsTi}x dD]}t |j|¡||<q Wt ¡ªt d¡d|jdfd|dfd|jfd|d fg}x"d D]}| d |||f¡qlWxd D]}| |||f¡qW| d t  |d¡f¡| d|df¡WdQRX|j j rL| dt   |j¡f¡| dt |jd¡f¡| dt |jd¡f¡| dt |jd¡f¡t|ƒS)z_Saved results from the dynamic nested sampling run. All saved bounds are also returned.)r¥rœÚidrÓr¸r›Únr;r8r:r9ÚlogzvarÚhÚ batch_nliveÚ batch_boundsr€ÚignorerÆrrÅr¥r©Zsamplesrœ)rërÓr¸r›rìZsamples_)r;r8r:r9rïrðr€rwríÚ informationrîNr_Z bound_iterr¨Z samples_boundr§r)r@rvr¬r>Úcatch_warningsÚ simplefilterr¸r©r·Úsqrtr¶rµrºÚdeepcopyr_r )rÝÚdrÉrFr4r4r5rF,s*      zDynamicSampler.resultscCs<|jd}t|ƒdks&t t |¡¡r*dStt |¡ƒSdS)a Estimate the effective number of posterior samples using the Kish Effective Sample Size (ESS) where `ESS = sum(wts)^2 / sum(wts^2)`. Note that this is `len(wts)` when `wts` are uniform and `1` if there is only one non-zero element in `wts`. r;rN)r¬rBr@r‡rPrr…)rÝr;r4r4r5r|Rs zDynamicSampler.n_effectivecCs|jS)zw Return list of papers that should be cited given the specified configuration of the sampler. )rÎ)rÝr4r4r5Ú citationsbszDynamicSampler.citationsç{®Gáz„?Fc csv|tjk r4t ¡t d¡t dt¡WdQRX|dkrBtj}|dkrPtj}|pX|j }|  ||¡}|d|j kr~t d¡| sª|  ¡t | |j|j|j||j|j|j|jd \\|_|_|_} } }|jrÖ| |_nd|_t|jƒ|_|j|j|j|jg} dd„| Dƒ|_|j|7_tj|jtd |_tj|jtd |_ |j!}|dkrT|j"}t#||j|j|j|j|j$|||j|j%|j&|j'|j |j(|j| d |_)|j)j*|_*t+j,|_-xt.|j)j/|| |||| d ƒD]î\}}t0|j1|j2|j3|j4|j5|j6|j7|j8|j9|j:|j;|j|j|j<|j=|j)j>d }|j? @|¡|jA @|¡|j|j:7_d |jB|j|_C|jBd7_Bt+jD|_-tE|j1|j2|j3|j4|j5|j6|j7|j8|j9|j:|j|j;|j<|j=|jC|jFdVqÊWt+jG|_-xìt.|j) H¡ƒD]Ú\}}t0|j1|j2|j3|j4|j5|j6|j7|j8|j9|j|j:|j;|j||j<|j=|j)j>d}|j? @|¡|jA @|¡d |jB|j|_C|jBd7_BtE|j1|j2|j3|j4|j5|j6|j7|j8|j9|j|j:|j;|j<|j=|jC|jFdVqÔWi}tI|jAd|jAdd\|d<|d<|d<|d<x2dD]*}|| J¡|jA|<|| J¡|j?|<qìWtjt|jAdƒtd |jAd<|jAd @|j¡|jAd @tj tjf¡d|_Kt+jL|_-dS)a Generate a series of initial samples from a nested sampling run using a fixed number of live points using an internal sampler from :mod:`~dynesty.nestedsamplers`. Instantiates a generator that will be called by the user. Parameters ---------- nlive : int, optional The number of live points to use for the baseline nested sampling run. Default is either nlive0 parameter of 500 update_interval : int or float, optional If an integer is passed, only update the bounding distribution every `update_interval`-th likelihood call. If a float is passed, update the bound after every `round(update_interval * nlive)`-th likelihood call. Larger update intervals can be more efficient when the likelihood function is quick to evaluate. If no value is provided, defaults to the value passed during initialization. first_update : dict, optional A dictionary containing parameters governing when the sampler will first update the bounding distribution from the unit cube (`'none'`) to the one specified by `sample`. maxiter : int, optional Maximum number of iterations. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). maxcall : int, optional Maximum number of likelihood evaluations. Iteration may stop earlier if termination condition is reached. Default is `sys.maxsize` (no limit). dlogz : float, optional Iteration will stop when the estimated contribution of the remaining prior volume to the total evidence falls below this threshold. Explicitly, the stopping criterion is `ln(z + z_est) - ln(z) < dlogz`, where `z` is the current evidence from all saved samples and `z_est` is the estimated contribution from the remaining volume. The default is `0.01`. logl_max : float, optional Iteration will stop when the sampled ln(likelihood) exceeds the threshold set by `logl_max`. Default is no bound (`np.inf`). n_effective: int, optional This option is deprecated and will be removed in a future release. live_points: list of 3 `~numpy.ndarray` each with shape (nlive, ndim) and optionally list of blobs associated with these likelihood calls (if blob=True in the sampler) A set of live points used to initialize the nested sampling run. Contains `live_u`, the coordinates on the unit cube, `live_v`, the transformed variables, and `live_logl`, the associated loglikelihoods. By default, if these are not provided the initial set of live points will be drawn from the unit `npdim`-cube. **WARNING: It is crucial that the initial set of live points have been sampled from the prior. Failure to provide a set of valid live points will lead to incorrect results.** Returns ------- worst : int Index of the live point with the worst likelihood. This is our new dead point sample. ustar : `~numpy.ndarray` with shape (npdim,) Position of the sample. vstar : `~numpy.ndarray` with shape (ndim,) Transformed position of the sample. loglstar : float Ln(likelihood) of the sample. logvol : float Ln(prior volume) within the sample. logwt : float Ln(weight) of the sample. logz : float Cumulative ln(evidence) up to the sample (inclusive). logzvar : float Estimated cumulative variance on `logz` (inclusive). h : float Cumulative information up to the sample (inclusive). nc : int Number of likelihood calls performed before the new live point was accepted. worst_it : int Iteration when the live (now dead) point was originally proposed. boundidx : int Index of the bound the dead point was originally drawn from. bounditer : int Index of the bound being used at the current iteration. eff : float The cumulative sampling efficiency (in percent). delta_logz : float The estimated remaining evidence expressed as the ln(ratio) of the current evidence. ÚoncezlThe n_effective option to DynamicSampler.sample_initial is deprecated and will be removed in future releasesNrz!Beware: `nlive_init <= 2 * ndim`!)rar“rxr€r”cSsg|]}t |¡‘qSr4)r@rv)rnrr4r4r5rpsz1DynamicSampler.sample_initial..)r )ržrŸr€r•)ÚmaxiterÚ save_samplesÚmaxcallrVÚdlogzÚresume)rër›rœr8r:r;r9rírîr¥r¸rìr€r§r¨rgY@r)r¡r¢r£r¤r:r;r9rírîr¥r€r¦r§r¨r©Ú delta_logz)rër›rœr8r:r;r9rírîr€r¥r¸rìr§r¨r)r¡r¢r£r¤r:r;r9rírîr€r¥r¦r§r¨r©rr8r:)r8r:r;r9rírî)r;r9rírîrërÓrïrðT)Mr@rQr>róÚfilterwarningsr?ÚDeprecationWarningrèrérÕÚ$_DynamicSampler__get_update_intervalržrêršr‘r’ryr“rxr€r”r–r—r˜r™rBrÛr¯rÅrƒr[r½r¾r®r±r­r°r²r³r´rŸr¶r_rr,rÖr‹r^Údictr¡r¢r£r¤r:r;r9rírîr¥r¦r§r¨rr×r·r¬r¸r©r-rrr1Úadd_live_pointsrÚtolistrÔr.)rÝrar]r±rûrýrVrþr|rrürÿZblobsr•rÈr®r¸rFÚadd_infoÚnew_valsZcurkr4r4r5Úsample_initialls0                  &  zDynamicSampler.sample_initialTc csT|ptj}|ptj}|p|j}|d|jkr6t d¡|sº| ||¡}t|||||d\} } } } } | |_|jj |_ | | |_ |_ t dd|_ |j| 7_|j| _|j}|| }|| }n"|j} | j}|j |j } } |}|}x$tt| jƒƒD]}| j d¡VqìWd}xìt| j|| ||d||dƒD]Ì\}}t|j|j|j|j|j|j||j||j|j | j!d }|j  "|¡|j|j7_d |j|j|_#|jd 7_|d 8}||j8}d}t$j%|_&t'|j|j|j|j|j|j||j|j |j#d Vq$W|r0|j| kr0t( )| ¡r0|dkr0|dkr0t d ¡t$j*|_&|s’t| j+dƒdkr’t(j, g| j+d<| g| j+d<dg| j+d<dg| j+d<dg| j+d<x²t|  -¡ƒD]¢\}}t|j|j|j|j|j|j||||j|j|j | j!d }|j  "|¡d |j|j|_#|jd 7_t'|j|j|j|j|j|j||j|j |j#d Vq W|`d|_dS)a Generate an additional series of nested samples that will be combined with the previous set of dead points. Works by hacking the internal `sampler` object. Instantiates a generator that will be called by the user. Parameters ---------- nlive_new : int Number of new live points to be added. Default is `500`. update_interval : int or float, optional If an integer is passed, only update the bounding distribution every `update_interval`-th likelihood call. If a float is passed, update the bound after every `round(update_interval * nlive)`-th likelihood call. Larger update intervals can be more efficient when the likelihood function is quick to evaluate. If no value is provided, defaults to the value passed during initialization. logl_bounds : tuple of size (2,), optional The ln(likelihood) bounds used to bracket the run. If `None`, the default bounds span the entire range covered by the original run. maxiter : int, optional Maximum number of iterations. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). maxcall : int, optional Maximum number of likelihood evaluations. Iteration may stop earlier if termination condition is reached. Default is `sys.maxsize` (no limit). save_bounds : bool, optional Whether or not to save past distributions used to bound the live points internally. Default is `True`. dlogz : float, optional The stopping point in terms of remaining delta(logz) Returns ------- worst : int Index of the live point with the worst likelihood. This is our new dead point sample. **Negative values indicate the index of a new live point generated when initializing a new batch.** ustar : `~numpy.ndarray` with shape (npdim,) Position of the sample. vstar : `~numpy.ndarray` with shape (ndim,) Transformed position of the sample. loglstar : float Ln(likelihood) of the sample. nc : int Number of likelihood calls performed before the new live point was accepted. worst_it : int Iteration when the live (now dead) point was originally proposed. boundidx : int Index of the bound the dead point was originally drawn from. bounditer : int Index of the bound being used at the current iteration. eff : float The cumulative sampling efficiency (in percent). rz"Beware: `nlive_batch <= 2 * ndim`!)r]rÄrµT)rÐrF)rþrVrûrýrürµrÿ) rër›rœr8r¥r¸r€rìr§r¨rgY@r) r¡r¢r£r¤r¥r¦r§r¨r©zˆWarning. The maximum likelihood not reached in the batch. You may not have enough livepoints and/or have highly multi-modal distributionr8r:g}Ô%­I²Ôr9rírî) rër›rœr8r¥r¸rìr€r§r¨rN).rèrérÕržr>r?rrÊrÇr_rÙrÚrrØrÅr¸Úit0rsrBrÂÚpopr‹r^rr¡r¢r£r¤r¥r¦r€r§r¨rr·r©rr/rÖrr@r†r2r¬rQr)rÝrþrÃr]rÄrûrýrµrÿrÇrÅrÆrUrVr Z maxcall_leftZ maxiter_leftrZiterated_batchr¸rFÚDr4r4r5Ú sample_batch¢sÎU                 zDynamicSampler.sample_batchc$ Cs¢t|jdƒdkrtdƒ‚i}i}x4dD],}t |j|¡||<t |j|¡||<q(Wt |jd¡|d<t|dƒ}|dt|dƒd|d<t|dƒ}|j|j}}|jd}|jd } |`t d d |_d \} } |d | |d | } } |d| |d| }}||}x||}n|}i}| | krv|d| |d<|}t | ƒ}| d7} n"|j d|d<|}t | ƒ}| d7} xdD]}|||||<qžW|j  |¡|jd  |¡y|d | } |d| }Wn tk rtj} d}YnXy|d | } |d| }Wn tk rNtj} d}YnXq"Wd}d}d}|jj}t |jd ¡}t |jd¡}xòtt||ƒƒD]à\}\}}|s|t|ƒdkr||||dkr||d…|k}| ¡}|dkr|}|t d|d¡}d }|s2|t |d|¡8}n|t t ||¡ ¡}|jd  |¡|rš|d8}|dkršd}qšW|jd dt|d d|d dƒks¬t‚|jd dt|d d|d dƒksÚt‚t|jd |jdd\} }!}"}#|jd |  ¡¡|jd |! ¡¡|jd |" ¡¡|jd |# ¡¡d|_tj tj|_|_|j d7_ | t|dƒg|jd <|||fg|jd<dS)zs Merge the most recent run into the previous (combined) run by "stepping through" both runs simultaneously.rërz#No new samples are currently saved.) rër›rœr8r¥r§r¸r¨rìrr€r:rÓrìrrðrïT)rÐ)rrr8) rër›rœr8r¥r§r¸r¨rr€FNgð?r:r6)r8r:r;r9rírî)rBrØrNr@rvr¬rPrÙrÚrrsr[rÓr·Ú IndexErrorrQr¶r•r‹rtrErCrÁÚlog1prDrRr‰rrŠr)$rÝZsaved_dZnew_drÉZnsavedZnnewZllminZllmaxZold_batch_boundsZold_batch_nliveZ idx_savedZidx_newZlogl_sZlogl_nZnlive_sZnlive_nZntotrrarZ add_sourceZadd_idxZ plateau_modeZplateau_counterZplateau_logdvolr:Z logl_arrayZ nlive_arrayroZcur_loglZ plateau_maskZnplateauZ new_logwtZnew_logzZ new_logzvarZnew_hr4r4r5Ú combine_runs†s°                  zDynamicSampler.combine_runsé<c)Csx|tjk r4t ¡t d¡t dt¡WdQRX| dkrBtj} | dkrPtj} | dkr^tj} | dkrltj} |dkrztj}|dkrˆtj}|dkr–tj}|dkr¢t }| dkr®i} |dkrÀd}t }nd}|dkrÐi}|rö|dkrît |j |j dƒ}||d<|pþ|j }|p |j }|j}|jd}tj tjf}t|| ƒ}t|| ƒ}|rb|jtjkrbt d t¡dSt||ƒ\}}t|ƒ|_zØ|jsxŠ|j||||||||dd D]j}|r²d}||j7}|d7}|dk rò|jtjkrò|j ¡rò| |¡|r¤||||d ||d q¤Wx t|j|ƒD]} |j }!t| || ƒ}"t| || ƒ}#|"d krš|#d krš|rš|j!rt|j"}$nt#}$||!||j$|$dd \}%}&|&d}'n d}%tj%}'|"d krö|#d krö|%sö|j&||| |#|"||||'||d }(|rèd}|(\}}}}n:|dtjkr.|r*||||| |'|d |ddPnPq"Wtj|_|dk rR| |¡Wd|dk rh| '¡|j( )¡XdS)a` **The main dynamic nested sampling loop.** After an initial "baseline" run using a constant number of live points, dynamically allocates additional (nested) samples to optimize a specified weight function until a specified stopping criterion is reached. Parameters ---------- nlive_init : int, optional The number of live points used during the initial ("baseline") nested sampling run. Default is the number provided at initialization maxiter_init : int, optional Maximum number of iterations for the initial baseline nested sampling run. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). maxcall_init : int, optional Maximum number of likelihood evaluations for the initial baseline nested sampling run. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). dlogz_init : float, optional The baseline run will stop when the estimated contribution of the remaining prior volume to the total evidence falls below this threshold. Explicitly, the stopping criterion is `ln(z + z_est) - ln(z) < dlogz`, where `z` is the current evidence from all saved samples and `z_est` is the estimated contribution from the remaining volume. The default is `0.01`. logl_max_init : float, optional The baseline run will stop when the sampled ln(likelihood) exceeds this threshold. Default is no bound (`np.inf`). n_effective_init: int, optional Minimum number of effective posterior samples needed during the baseline run. If the estimated "effective sample size" (ESS) exceeds this number, sampling will terminate. Default is no ESS (`np.inf`). This option is deprecated and will be removed in a future release. nlive_batch : int, optional The number of live points used when adding additional samples from a nested sampling run within each batch. Default is the number provided at init wt_function : func, optional A cost function that takes a :class:`Results` instance and returns a log-likelihood range over which a new batch of samples should be generated. The default function simply computes a weighted average of the posterior and evidence information content as:: weight = pfrac * pweight + (1. - pfrac) * zweight wt_kwargs : dict, optional Extra arguments to be passed to the weight function. maxiter_batch : int, optional Maximum number of iterations for the nested sampling run within each batch. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). maxcall_batch : int, optional Maximum number of likelihood evaluations for the nested sampling run within each batch. Iteration may stop earlier if the termination condition is reached. Default is `sys.maxsize` (no limit). maxiter : int, optional Maximum number of iterations allowed. Default is `sys.maxsize` (no limit). maxcall : int, optional Maximum number of likelihood evaluations allowed. Default is `sys.maxsize` (no limit). maxbatch : int, optional Maximum number of batches allowed. Default is `sys.maxsize` (no limit). n_effective: int, optional Minimum number of effective posterior samples needed during the entire run. If the estimated "effective sample size" (ESS) exceeds this number, sampling will terminate. Default is max(10000, ndim^2) stop_function : func, optional A function that takes a :class:`Results` instance and returns a boolean indicating that we should terminate the run because we've collected enough samples. stop_kwargs : float, optional Extra arguments to be passed to the stopping function. use_stop : bool, optional Whether to evaluate our stopping function after each batch. Disabling this can improve performance if other stopping criteria such as :data:`maxcall` are already specified. Default is `True`. save_bounds : bool, optional Whether or not to save distributions used to bound the live points internally during dynamic live point allocation. Default is `True`. print_progress : bool, optional Whether to output a simple summary of the current run that updates each iteration. Default is `True`. print_func : function, optional A function that prints out the current state of the sampler. If not provided, the default :meth:`results.print_fn` is used. live_points: list of 3 `~numpy.ndarray` each with shape (nlive, ndim) and optionally list of blobs associated with these likelihood calls (if blob=True in the sampler) A set of live points used to initialize the nested sampling run. Contains `live_u`, the coordinates on the unit cube, `live_v`, the transformed variables, and `live_logl`, the associated loglikelihoods. By default, if these are not provided the initial set of live points will be drawn from the unit `npdim`-cube. **WARNING: It is crucial that the initial set of live points have been sampled from the prior. Failure to provide a set of valid live points will lead to incorrect results.** resume: bool, optional If resume is set to true, we will try to resume a previously interrupted run checkpoint_file: string, optional if not None The state of the sampler will be saved into this file every checkpoint_every seconds checkpoint_every: float, optional The number of seconds between checkpoints that will save the internal state of the sampler rúzmThe n_effective_init option to DynamicSampler.run_nested is deprecated and will be removed in future releasesNTFi'rgrziYou tried to resume the run that has ended successfully. This is not supported. No sampling was performed) rarþrýrûrVrr|rÿrür)ÚnbatchrþrV)rxryrzr) raÚ wt_functionÚ wt_kwargsrûrýrµÚprint_progressÚ print_funcÚstop_valrÿÚcheckpoint_file)rrrUrV)*r@rQr>rórr?rrèrérrrPr“rÕrÅr¸rRrÖrr3rr rrÜrÔr r¥r1Úis_timerärsrÓrFrÒryrrrxÚnanÚ add_batchÚcloser’Ú history_save))rÝrÛZ maxiter_initZ maxcall_initZ dlogz_initZ logl_max_initZn_effective_initZ nlive_batchrrZ maxiter_batchZ maxcall_batchrûrýZmaxbatchr|rÏZ stop_kwargsZuse_stoprµrrrrÿrÚcheckpoint_everyZdefault_stop_functionrÅrÆrÄÚpbarrFrìrqZmcallZmiterryr}Z stop_valsrZpassbackr4r4r5Ú run_nestedsö)                   zDynamicSampler.run_nestedéôrTcCsR|ptj}|ptj}|pt}|p"i}| p,tj} |j}|dkrL|dk rLtdƒ‚|dkrd|dkrdtdƒ‚|dkst|dkr~|||ƒ}|dkr˜tj tj}}n|\}}|dd|d dd }}|j|j d |j }}}|dk rø|dk ròt |ƒ}n|j }|d krF|d krFt | | ƒ\}} zðd}xæ|j|||||| | d D]Ê}| rHd} |jd krf||j7}|d 7}t|j|j|j|jdtjtj||tj|j|j|j|j|jtjd}| rÈ| ||||d | ||d|dk r:|jtjkr:|jtjkr:| ¡r:| |¡q:WWd|dk r| ¡|j  !¡X| "¡tj|_||||fStdƒ‚dS)ae Allocate an additional batch of (nested) samples based on the combined set of previous samples using the specified weight function. Parameters ---------- nlive : int, optional The number of live points used when adding additional samples in the batch. Default is `500`. mode: string, optional How to allocate a new batch. The possible values are 'auto', 'weight', 'full', 'manual' 'weight' means to use the weight_function to decide the optimal logl range. 'full' means sample the whole posterior again 'auto' means choose automatically, which currently means using 'weight' 'manual' means that logl_bounds need to be explicitely specified wt_function : func, optional A cost function that takes a `Results` instance and returns a log-likelihood range over which a new batch of samples should be generated. The default function simply computes a weighted average of the posterior and evidence information content as:: weight = pfrac * pweight + (1. - pfrac) * zweight wt_kwargs : dict, optional Extra arguments to be passed to the weight function. maxiter : int, optional Maximum number of iterations allowed. Default is `sys.maxsize` (no limit). maxcall : int, optional Maximum number of likelihood evaluations allowed. Default is `sys.maxsize` (no limit). logl_bounds : tuple of size (2,), optional The ln(likelihood) bounds used to bracket the run. If `None`, the provided `wt_function` will be used to determine the bounds (this is the default behavior). save_bounds : bool, optional Whether or not to save distributions used to bound the live points internally during dynamic live point allocations. Default is `True`. print_progress : bool, optional Whether to output a simple summary of the current run that updates each iteration. Default is `True`. print_func : function, optional A function that prints out the current state of the sampler. If not provided, the default :meth:`results.print_fn` is used. stop_val : float, optional The value of the stopping criteria to be passed to :meth:`print_func`. Used internally within :meth:`run_nested` to keep track of progress. resume: bool, optional If resume is set to true, we will try to resume a previously interrupted run checkpoint_file: string, optional if not None The state of the sampler will be saved into this file every checkpoint_every seconds checkpoint_every: float, optional The number of seconds between checkpoints that will save the internal state of the sampler. If this is None, we we will use the timer created in run_nested() ZmanualNz6specified logl_bounds are only allowed for manual modez0logl_bounds need to be specified for manual modeÚautorTr9r6rwrrr)rÃrþrÄrûrýrµrÿF)r¡r¢r£r¤r€r:r;r9rírîr¥r¦r§r¨r©r)rrrUrVz=add_batch called with no leftover function callsor iterations)#rèrérr@rrFr\rQrÅr¸rÓrrÜr r r¡r¥rr¢r£r¤r¦r§r¨r©rÖrr2r0rrärr’rr)rÝrarþÚmoderrrûrýrÄrµrrrrÿrrrqrUrVr9rírÅrÆrìÚtimerrrFZ cur_resultsr4r4r5rVsš\               zDynamicSampler.add_batch)N)rùNNNNNTF)r!rùrTNNNNNTTNNFNN)r'r(r)r*rÞrárâräÚ staticmethodrårrêÚpropertyrFr|rør@rQr r rr rr4r4r4r5rPsœ<O    &   . ] ,)NF)NNNF)NNNFN)NN)+r*rèr>rÁrºÚenumrÚnumpyr@Z scipy.specialrZnestedsamplersrrrrr rFr Úutilsr r r rrrrrrrrrrÚ__all__r­rrIrrdrršrÊrr4r4r4r5Ú sJ   <$ Y!  ; 8