ó šßÈ[c@`sódZddlmZmZmZmZddlZddlZddl m Z ddl m Z ddl mZdd d d d gZddd d„Zdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdS(uÑ Bayesian Blocks for Time Series Analysis ======================================== Dynamic programming algorithm for solving a piecewise-constant model for various datasets. This is based on the algorithm presented in Scargle et al 2012 [1]_. This code was ported from the astroML project [2]_. Applications include: - finding an optimal histogram with adaptive bin widths - finding optimal segmentation of time series data - detecting inflection points in the rate of event data The primary interface to these routines is the :func:`bayesian_blocks` function. This module provides fitness functions suitable for three types of data: - Irregularly-spaced event data via the :class:`Events` class - Regularly-spaced event data via the :class:`RegularEvents` class - Irregularly-spaced point measurements via the :class:`PointMeasures` class For more fine-tuned control over the fitness functions used, it is possible to define custom :class:`FitnessFunc` classes directly and use them with the :func:`bayesian_blocks` routine. One common application of the Bayesian Blocks algorithm is the determination of optimal adaptive-width histogram bins. This uses the same fitness function as for irregularly-spaced time series events. The easiest interface for creating Bayesian Blocks histograms is the :func:`astropy.stats.histogram` function. References ---------- .. [1] http://adsabs.harvard.edu/abs/2012arXiv1207.5578S .. [2] http://astroML.org/ https://github.com//astroML/astroML/ i(tabsolute_importtdivisiontprint_functiontunicode_literalsNi(t signature(tAstropyUserWarning(trangeu FitnessFuncuEventsu RegularEventsu PointMeasuresubayesian_blocksueventscK`s”itd6td6td6}|j||ƒ}t|ƒtkr]t|tƒr]||}n$t|tƒru|}n tdƒ‚|j |||ƒS(uø Compute optimal segmentation of data with Scargle's Bayesian Blocks This is a flexible implementation of the Bayesian Blocks algorithm described in Scargle 2012 [1]_. Parameters ---------- t : array_like data times (one dimensional, length N) x : array_like (optional) data values sigma : array_like or float (optional) data errors fitness : str or object the fitness function to use for the model. If a string, the following options are supported: - 'events' : binned or unbinned event data. Arguments are ``gamma``, which gives the slope of the prior on the number of bins, or ``ncp_prior``, which is :math:`-\ln({\tt gamma})`. - 'regular_events' : non-overlapping events measured at multiples of a fundamental tick rate, ``dt``, which must be specified as an additional argument. Extra arguments are ``p0``, which gives the false alarm probability to compute the prior, or ``gamma``, which gives the slope of the prior on the number of bins, or ``ncp_prior``, which is :math:`-\ln({\tt gamma})`. - 'measures' : fitness for a measured sequence with Gaussian errors. Extra arguments are ``p0``, which gives the false alarm probability to compute the prior, or ``gamma``, which gives the slope of the prior on the number of bins, or ``ncp_prior``, which is :math:`-\ln({\tt gamma})`. In all three cases, if more than one of ``p0``, ``gamma``, and ``ncp_prior`` is chosen, ``ncp_prior`` takes precedence over ``gamma`` which takes precedence over ``p0``. Alternatively, the fitness parameter can be an instance of :class:`FitnessFunc` or a subclass thereof. **kwargs : any additional keyword arguments will be passed to the specified :class:`FitnessFunc` derived class. Returns ------- edges : ndarray array containing the (N+1) edges defining the N bins Examples -------- Event data: >>> t = np.random.normal(size=100) >>> edges = bayesian_blocks(t, fitness='events', p0=0.01) Event data with repeats: >>> t = np.random.normal(size=100) >>> t[80:] = t[:20] >>> edges = bayesian_blocks(t, fitness='events', p0=0.01) Regular event data: >>> dt = 0.05 >>> t = dt * np.arange(1000) >>> x = np.zeros(len(t)) >>> x[np.random.randint(0, len(t), len(t) // 10)] = 1 >>> edges = bayesian_blocks(t, x, fitness='regular_events', dt=dt) Measured point data with errors: >>> t = 100 * np.random.random(100) >>> x = np.exp(-0.5 * (t - 50) ** 2) >>> sigma = 0.1 >>> x_obs = np.random.normal(x, sigma) >>> edges = bayesian_blocks(t, x_obs, sigma, fitness='measures') References ---------- .. [1] Scargle, J et al. (2012) http://adsabs.harvard.edu/abs/2012arXiv1207.5578S See Also -------- astropy.stats.histogram : compute a histogram using bayesian blocks ueventsuregular_eventsumeasuresu fitness parameter not understood( tEventst RegularEventst PointMeasurestgetttypet issubclasst FitnessFunct isinstancet ValueErrortfit(tttxtsigmatfitnesstkwargst FITNESS_DICTtfitfunc((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pytbayesian_blocks9sX  !  R cB`sheZdZdd d d„Zd d d„Zd„Zd„Zed„ƒZ d„Z d d d„Z RS( u.Base class for bayesian blocks fitness functions Derived classes should overload the following method: ``fitness(self, **kwargs)``: Compute the fitness given a set of named arguments. Arguments accepted by fitness must be among ``[T_k, N_k, a_k, b_k, c_k]`` (See [1]_ for details on the meaning of these parameters). Additionally, other methods may be overloaded as well: ``__init__(self, **kwargs)``: Initialize the fitness function with any parameters beyond the normal ``p0`` and ``gamma``. ``validate_input(self, t, x, sigma)``: Enable specific checks of the input data (``t``, ``x``, ``sigma``) to be performed prior to the fit. ``compute_ncp_prior(self, N)``: If ``ncp_prior`` is not defined explicitly, this function is called in order to define it before fitting. This may be calculated from ``gamma``, ``p0``, or whatever method you choose. ``p0_prior(self, N)``: Specify the form of the prior given the false-alarm probability ``p0`` (See [1]_ for details). For examples of implemented fitness functions, see :class:`Events`, :class:`RegularEvents`, and :class:`PointMeasures`. References ---------- .. [1] Scargle, J et al. (2012) http://adsabs.harvard.edu/abs/2012arXiv1207.5578S gš™™™™™©?cC`s||_||_||_dS(N(tp0tgammat ncp_prior(tselfRRR((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyt__init__Äs  cC`sõtj|dtƒ}|d k r3tj|ƒ}n|d k rQtj|ƒ}ntj|ƒ}|jdkr~tdƒ‚ntj|dtdtƒ\}}}|d kr|d k rÉtdƒ‚nd}t |ƒt |ƒkrùtj |ƒ}ntj |ƒ}|}n†tj|ƒ}|j d d |j fgkrMtdƒ‚n|tj|ƒ7}t |ƒt |ƒkr‡tdƒ‚n|}||}|d kr¬d}n<tj|ƒ}|j d d|j fgkrètd ƒ‚n|||fS(u®Validate inputs to the model. Parameters ---------- t : array_like times of observations x : array_like (optional) values observed at each time sigma : float or array_like (optional) errors in values x Returns ------- t, x, sigma : array_like, float or None validated and perhaps modified versions of inputs tdtypeiu!t must be a one-dimensional arrayt return_indextreturn_inverseu*If sigma is specified, x must be specifiedux does not match shape of tu6Repeated values in t not supported when x is specifiedu#sigma does not match the shape of xN((i((i(tnptasarraytfloattNonetarraytndimRtuniquetTruetlent ones_liketbincounttshapetsizet zeros_like(RRRRtunq_ttunq_indtunq_inv((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pytvalidate_inputÉs@        cK`s tƒ‚dS(N(tNotImplementedError(RR((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyRscC`s dtjd|j|dƒS(uD Empirical prior, parametrized by the false alarm probability ``p0`` See eq. 21 in Scargle (2012) Note that there was an error in this equation in the original Scargle paper (the "log" was missing). The following corrected form is taken from https://arxiv.org/abs/1304.2818 igR¸…ëaR@gd;ßO—Þ¿(R!tlogR(RtN((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pytp0_priors cC`st|jƒjjƒS(N(RRt parameterstkeys(R((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyt _fitness_argsscC`sb|jdk r|jS|jdk r6tj|jƒ S|jdk rR|j|ƒStdƒ‚dS(uj If ``ncp_prior`` is not explicitly defined, compute it from ``gamma`` or ``p0``. u_``ncp_prior`` is not defined, and cannot compute it as neither ``gamma`` nor ``p0`` is defined.N(RR$RR!R4RR6R(RR5((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pytcompute_ncp_prior"s cC`sX|j|||ƒ\}}}d|jkrGtj|ƒ|d}nd|jkrg||d}nd|jkr‹|||d}ntj|d d|d|d |dgƒ}|d|}t|ƒ} tj| dtƒ} tj| dtƒ} |j d kr |j | ƒ} nxÃt | ƒD]µ} i}d |jkri|| d || d|d iu3regular events: N/M > 1. Is the time step correct?i(RYR!RXRSRTRR4(RRWRVtM_ktN_over_Mtepstone_m_NM((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyRÛs     N(RORPRQR$RR2R(((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyR¼s R cB`s2eZdZdddd„Zd„Zd„ZRS(u#Bayesian blocks fitness for point measures Parameters ---------- p0 : float (optional) False alarm probability, used to compute the prior on :math:`N_{\rm blocks}` (see eq. 21 of Scargle 2012). If gamma is specified, p0 is ignored. ncp_prior : float (optional) If specified, use the value of ``ncp_prior`` to compute the prior as above, using the definition :math:`{\tt ncp\_prior} = -\ln({\tt gamma})`. If ``ncp_prior`` is specified, ``gamma`` and ``p0`` are ignored. gš™™™™™©?cC`s tt|ƒj|||ƒdS(N(RUR R(RRRR((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyRûscC`s||d|S(Ni((Rta_ktb_k((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyRþscC`s7|dkrtdƒ‚ntt|ƒj|||ƒS(Nu&x must be specified for point measures(R$RRUR R2(RRRR((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyR2s N(RORPRQR$RRR2(((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyR ìs (RQt __future__RRRRRStnumpyR!tutils.compat.funcsigsRtutils.exceptionsRtextern.six.movesRt__all__R$RtobjectR RRR (((s<lib/python2.7/site-packages/astropy/stats/bayesian_blocks.pyt's"     fð,0