B zd[@sndZddlZddlZddlZddlZddlmZddlmZddl m Z m Z GdddeZ Gd d d Z dS) z&Markov chains with parallel tempering.N) BaseChain)Chain) ChainData detect_dtypesc@seZdZdZdIddZedd ZejdJd d Zed d Zed dZ e jddZ eddZ ddZ eddZ eddZ eddZeddZejddZeddZejddZed d!Zed"d#Zd$d%ZdKd&d'Zed(d)Zejd*d)Zed+d,Zed-d.Zed/d0Zed1d2Zed3d4Zed5d6Zed7d8Zed9d:Zed;d<Zed=d>Zed?d@Z dAdBZ!dCdDZ"dEdFZ#dGdHZ$dS)LParallelTemperedChainaA collection of parallel tempered Markov chains. Parameters ---------- parameters : list or tuple List of the parameter names to sample. model : object Any object that can be called with keyword arguments that map parameter names to values. When called, the object must a tuple of ``logl, logp`` where ``logp`` is the log prior and ``logl`` is the log likelihood at the given point. The model may optionally return a dictionary in addition that maps strings to any arbitrary data. proposals : list of epsie.proposals instances List of proposal classes to use for the parameters. There must be one and only one proposal for every parameter. A single proposal may cover multiple parameters. Proposals must be instances of classes that inherit from :py:class:`epsie.proposals.BaseProposal`. betas : array of floats, optional Array of inverse temperatures. Each beta must be in range 0 (= infinite temperature; i.e., only sample the prior) <= beta <= 1 (= coldest temperate; i.e., sample the standard posterior). Default is a single beta = 1. swap_interval : int, optional For a parallel tempered chain, how often to calculate temperature swaps. Default is 1 (= swap on every iteration). adaptive_annealer : object, optional Adaptive annealing that adjusts the temperature levels during runtime. By default `None`, meaning no annealing. bit_generator : :py:class:`epsie.BIT_GENERATOR` instance, optional Use the given random bit generator for generating random variates. If an int or None is provided, a generator will be created instead using ``bit_generator`` as a seed. chain_id : int, optional An interger identifying which chain this is. Default is 0. Attributes ---------- iteration lastclear scratchlen positions stats acceptance blobs start_position stats0 blob0 current_position current_stats current_blob bit_generator random_state state hasblobs chain_id : int or None Integer identifying the chain. ?rNrc s__d_|_|_d_d_|_|dk rD|jj dkrt dgdt ij dd_t dgdt ij d__ d_d_|_fddjD_tddjD_dS) Nracceptance_ratio)dtypesntemps swap_indexc s,g|]$}tddDj|dqS)cSsg|]}t|qS)copydeepcopy).0pr r `/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/epsie/chain/ptchain.py zsz=ParallelTemperedChain.__init__...) bit_generatorchain_idbeta)rr)rr)rmodel parameters proposalsselfr rrysz2ParallelTemperedChain.__init__..css|] }|jVqdS)N)transdimensional)rchainr r r ~sz1ParallelTemperedChain.__init__..)rr_betasbetas swap_interval_temperature_acceptance_temperature_swapsadaptive_annealersetup_annealingr rfloatintr_bit_generatorZ_random_generatorrchainsanyr) rrrrrr r#rrr )rrrrrr__init__Ys2      zParallelTemperedChain.__init__cCs|jS)N)r')rr r rrsz#ParallelTemperedChain.bit_generatorcCs"|dkrtjd|jd}||_dS)aeSets the random bit generator Parameters ---------- bit_generator : :py:class:`epsie.BIT_GENERATOR` instance, optional Use the given random bit generator for generating random variates. If an int or None is provided, a generator will be created instead using ``bit_generator`` as a seed. N)stream)epsieZcreate_bit_generatorrr')rrr r rrs  cCs |jdjS)z$Returns the random number generator.r)r(random_generator)rr r rr-sz&ParallelTemperedChain.random_generatorcCs|jjS)z.The current state of the random bit generator.)rstate)rr r r random_statesz"ParallelTemperedChain.random_statecCs ||j_dS)zSets the state of bit_generator. Parameters ---------- state : dict Dictionary giving the state to set. N)rr.)rr.r r rr/s cCsddt|jDS)ajReturns the current state of the chain. The state consists of everything needed such that setting a chain's state using another's state will result in identical results. Returns ------- dict : Dictionary of ``tk -> chains[tk].state``, where ``tk`` is the index of each temperature chain. cSsi|]\}}|j|qSr )r.)rtkrr r r sz/ParallelTemperedChain.state..) enumerater()rr r rr.s zParallelTemperedChain.statecCs&x |D]}|j|||qWdS)aSets the state of the chain using the given dict. .. warning:: Running this will clear the chain's current memory, and replace its current position with what is saved in the state. Parameters ---------- state : dict Dictionary of ``tk -> dict`` mapping indices of the temperature chains to the state they should be set to. N)r( set_state)rr.r0r r rr3s zParallelTemperedChain.set_statecCs |jdjS)z Whether the model returns blobs.r)r(hasblobs)rr r rr4szParallelTemperedChain.hasblobscCs |jdjS)z/The number of times the chain has been stepped.r)r( iteration)rr r rr5szParallelTemperedChain.iterationcCs |jdjS)zMReturns the iteration of the last time the chain memory was cleared. r)r( lastclear)rr r rr6szParallelTemperedChain.lastclearcCs |jdjS)z%The length of the scratch space used.r)r( scratchlen)rr r rr7sz ParallelTemperedChain.scratchlencCsbx|jD] }||_qW|jdkr^y(|j||j|j||jWntk r\YnXdS)aSet the scratch length to the given value. This will immediately increase the scratch length to ``n``. If the chain is already longer than ``n``, this will have no immediate impact. However, the next time ``clear`` is called, the scratch length will be reset to ``n``. Parameters ---------- n : int The length to set. rN)r(r7r r"Zset_lenr r! ValueError)rnrr r rr7s   cCs|jS)z8Returns the betas (=1 / temperatures) used by the chain.)r)rr r rrszParallelTemperedChain.betascCsvt|ttfr|g}t|tjs*t|}|dks@tdd|k|dk@ s\t dt |ddd|_ dS)z>Checks that the betas are in the allowed range before setting.g?zuNo betas = 1 found. This means that the normal posterior (i.e., likelihood * prior) will not be sampled by the chain.rrz!all betas must be in range [0, 1]N) isinstancer%r&numpyZndarrayarrayr)loggingwarningallr8sortr)rrr r rrs    cCs d|jS)z9Returns the temperatures (= 1 / betas) used by the chain.g?)r)rr r r temperaturessz"ParallelTemperedChain.temperaturescCs t|jS)z5Returns the number of temperatures used by the chain.)lenr)rr r rr szParallelTemperedChain.ntempscCsbt|jd|}tt|t|d}||jx$t|jD]\}}t||||<q@W| S)zConcatenates dictionary attributes over all of the temperatures. Parameters ---------- attr : str The name of the attribute to get from the chains. The attribute is assumed to return a dictionary. r)r ) getattrr(rlistkeysrextendr r2asdict)rattrdoutr0rr r r_concatenate_dictss  z(ParallelTemperedChain._concatenate_dictscsFdkr"ttfdd|j}nttfdd|j}t|S)zConcatenates array attributes over all of the temperatures. Returned array has shape ``[ntemps x] niterations``. Ncs t|S)N)rD)x)rIr r0z;ParallelTemperedChain._concatenate_arrays..cst|S)N)rD)rM)rIitemr rrN2rO)rEmapr(r<stack)rrIrPZarrsr )rIrPr_concatenate_arrays*sz)ParallelTemperedChain._concatenate_arrayscCs |dS)zDictionary mapping parameters to their start position. If the start position hasn't been set, raises a ``ValueError``. start_position)rL)rr r rrT5sz$ParallelTemperedChain.start_positioncs@|_x0t|jD]"\}fddD}||_qWdS)amSets the starting position. This also evaulates the log likelihood and log prior at the starting position, as well as determine if the model returns blob data. Parameters ---------- position : dict Dictionary mapping parameters to values. Values should be numpy arrays with length = ntemps. csi|]}||qSr r )rparam)positionr0r rr1Lsz8ParallelTemperedChain.start_position..N)r_startr2r(rT)rrVrZposkr )rVr0rrT=s cCs |dS)aDictionary of the log likelihood and log prior at the start position. The values of the returned dictionary are arrays of length ``ntemps``, ordered by increasing temperature. Raises a ``ValueError`` if the start position has not been set yet. stats0)rL)rr r rrXOs zParallelTemperedChain.stats0cCs|jr|d}nd}|S)aEThe blob data of the starting position, as a dictionary. If ``hasblobs`` is False, just returns None. Otherwise, the values of the returned dictionary are arrays of length ``ntemps``, ordered by increasing temperature. Raises a ``ValueError`` if ``set_start`` has not been run yet. blob0N)r4rL)rblobr r rrY[s  zParallelTemperedChain.blob0cCs |dS)zThe history of all of the positions, as a structred array. If ``ntemps > 1``, the returned array has shape ``ntemps x niterations``. Otherwise, the returned array has shape ``niterations``. positions)rS)rr r rr[kszParallelTemperedChain.positionscCs |dS)zThe history of all of the stats, as a structred array. If ``ntemps > 1``, the returned array has shape ``ntemps x niterations``. Otherwise, the returned array has shape ``niterations``. stats)rS)rr r rr\uszParallelTemperedChain.statscCs |dS)aThe history of all of acceptance ratios and accepted booleans, as a structred array. If ``ntemps > 1``, the returned array has shape ``ntemps x niterations``. Otherwise, the returned array has shape ``niterations``. acceptance)rS)rr r rr]s z ParallelTemperedChain.acceptancecCs0|jdkrdS|jdt||j}|djS)aAThe history of the acceptance ratios between temperatures. The returned array has shape ``ntemps-1 x (niterations/swap_interval)`` if ``ntemps > 1``. Otherwise, returns None. .. note:: This does not return a structured array, since there is only one field. Nr )r!rCr T)rrKr r rtemperature_acceptances z,ParallelTemperedChain.temperature_acceptancecCs0|jdkrdS|jdt||j}|djS)a)The history of all of the temperature swaps. The returned array has shape ``ntemps x (niterations/swap_interval)`` if ``ntemps > 1``. Otherwise, returns None. .. note:: This does not return a structured array, since there is only one field. Nr )r"rCr r^)rrKr r rtemperature_swapss z'ParallelTemperedChain.temperature_swapscCs|jr|d}nd}|S)a$The history of all of the blob data, as a structured array. If the model does not return blobs, this is just ``None``. If ``ntemps > 1``, the returned array has shape ``ntemps x niterations``. Otherwise, the returned array has shape ``niterations``. blobsN)r4rS)rrar r rras  zParallelTemperedChain.blobscCs |dS)z0Dictionary of the current position of the chain.current_position)rL)rr r rrbsz&ParallelTemperedChain.current_positioncCs |dS)z\Dictionary giving the log likelihood and log prior of the current position. current_stats)rL)rr r rrcsz#ParallelTemperedChain.current_statscCs|js d}n |d}|S)zDictionary of the blob data of the current position. If the model does not return blobs, just returns ``None``. N current_blob)r4rL)rrZr r rrds z"ParallelTemperedChain.current_blobcCsJx|jD] }|qW|jdkrF|j|j}|j||j|dS)zClears memory of the current chain, and sets start position to the current position. New scratch space will be created with length equal to ``scratch_len``. rN)r(clearr r7r r!r")rrtlenr r rres      zParallelTemperedChain.clearcCsh|j||j||j|d}|jdkrP|j||j|d<|j||j|d<|jrd|j||d<|S)z5Returns all of the chain data at the requested index.)r[r\r]rr`r_ra) r[r\r]r r`r r_Z _hasblobsra)rindexrKr r r __getitem__s z!ParallelTemperedChain.__getitem__cCs>x|jD] }|qW|jdkr:|j|jdkr:|dS)z:Evolves all of the temperatures by one iteration. rrN)r(stepr r5r swap_temperatures)rrr r rris  zParallelTemperedChain.stepcsj}tjjtd}|dd}tjd}tj}xtjdddD]}||}|d}|d|} ||} ||| |} | dkrd} d} n(t ||| |} j }|| k} | r| ||<|||<n| }| ||<qRWfdd |D}fd d |D}j r(fd d |D}j rBfd d |D}jjd}x\tjD]N\}}|||j|<|||j|<j r|||_j r^|||j|<q^Wd |ij|j<d|ij|j<jdk rdS)zComputes acceptance ratio between temperatures and swaps them. The positions, stats, and (if they exist) blobs are swapped. The acceptance is not swapped, however. )ZdtypeZloglr:rrg?Tcsg|]}j|jqSr )r(rb)rswk)rr rr)sz;ParallelTemperedChain.swap_temperatures..csg|]}j|jqSr )r(rc)rrk)rr rr+scsg|]}j|jqSr )r( _active_props)rrk)rr rr.scsg|]}j|jqSr )r(rd)rrk)rr rr1sr r N)rcr<Zaranger r&Zzerosdiffrrangeexpr-uniformrr4r5r6r2r(Z _positionsZ_statsrlZ_blobsr!r r"r#)rr\r ZloglkarsZdbetasr0rkZtjZlogljZswjZlogararZswapuZ new_positionsZ new_stats new_activeZ new_blobsiirr )rrrjsX            z'ParallelTemperedChain.swap_temperatures)rrNNr)N)N)%__name__ __module__ __qualname____doc__r*propertyrsetterr-r/r.r3r4r5r6r7rrBr rLrSrTrXrYr[r\r]r_r`rarbrcrdrerhrirjr r r rrsN9 '                     rc@sFeZdZdZdZdZdZdddZdd Zd d Z d d Z ddZ dS)DynamicalAnnealeruClass for dynamical parallel tempering. This is based on the algorithm described in [1]. Parameters ---------- tau : int, optional Defines the swap iteration at which adjustments have been reduced to half their initial amplitude ([1]). Default value is 1000. nu : int, optional Defines the initial amplitude of adjustments ([1]). Default values is 10 Tmax_prior: bool, optional Whether to set the hottest chain temperature to infinity. This only rewrites the hottest chain temperature to be infty and keeps the other chains as they were. By default sets it to infinity. References ---------- [1] W. D. Vousden, W. M. Farr, I. Mandel, Dynamic temperature selection for parallel tempering in Markov chain Monte Carlo simulations, Monthly Notices of the Royal Astronomical Society, Volume 455, Issue 2, 11 January 2016, Pages 1919–1937, https://doi.org/10.1093/mnras/stv2422 N TcCs|||||_dS)N) setup_decay _Tmax_prior)rtaunuZ Tmax_priorr r rr*ds zDynamicalAnnealer.__init__cCs ||kstdS||_||_dS)z(Set up constants for the vanishing decayz'`tau` must be at least larger than `nu`N)r8_tau_nu)rrrr r rrhszDynamicalAnnealer.setup_decaycCs0ttd|dd|_|jr,d|d<dS)z;Calculates the initial log diffs between temperature levelsg?Nr:g)r<logrm_Sr)rrr r rr$osz!DynamicalAnnealer.setup_annealingcCsd|jdd||jS)z] Vanishign decay to ensure detailed balance at later stages. Is set by `tau` and `nu`g?r)rr)rr5r r r_decayuszDynamicalAnnealer._decaycs|j|j|jdddfddk<jtfddt|jdD7_xHtd|jdD]4}dd|j|dt j|d|j|<qlWdS)Nr:g?rcs*g|]"}||dqS)r)r)ri)rqr5rr rr~sz.DynamicalAnnealer.__call__..) r5r r_rr<r=rnr rro)rrrr )rqr5rr__call__zs  zDynamicalAnnealer.__call__)r}r~T) rvrwrxryrrrr*rr$rrr r r rr|Es r|)ryr>r<rr,baserrrZ chaindatarrrr|r r r rs  +