B ²ô`zOã@s\dZddlmZddlmZddlmZddlZddlZddlZddl m Z ddl m ZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZdgZe jdejde  ej¡j!de j"dej"de  ej"¡j!de j#dej#de  ej#¡j!di Z$Gdd„dej%ƒZ&dd„Z'dd„Z(dd„Z)dd„Z*d dd„Z+dS)!zThe Bates distribution class.é)Úabsolute_import)Údivision)Úprint_functionN)Úv2)Ú_numpy)Úsigmoid)Ú distribution)Ú assert_util)Údistribution_util)Ú dtype_util)Ú prefer_static)Úreparameterization)Úsamplers)Ú tensor_utilÚBatesgÀR@g9@g@csÒeZdZdZd.‡fdd„ Zedd „ƒZed d „ƒZe d d „ƒZ e dd„ƒZ e dd„ƒZ dd„Z dd„Zdd„Zdd„Zdd„Zd/dd„Zdd „Zd!d"„Zd#d$„Ze d%¡d&d'„ƒZd(d)„Zd*d+„Zd,d-„Z‡ZS)0raÐBates distribution. The Bates distribution is the distribution of the average of `total_count` independent samples from `Uniform(low, high)`. It is parameterized by the interval bounds `low` and `high`, and `total_count`, the number of samples. Although some care has been taken to avoid numerical issues, the `pdf`, `cdf`, and log versions thereof may still exhibit numerical instability. They are relatively stable near the tails; however near the mode they are unstable if `total_count` is greater than about `75` for `tf.float64`, `25` for `tf.float32`, and `7` for `tf.float16`. Beyond these limits a warning will be shown if `validate_args=False`; otherwise an exception is thrown. For high `total_count`, consider using a `Normal` approximation. #### Mathematical Details The probability density function (pdf) is supported in the interval `[low, high]`. If `[low, high]` is the unit interval `[0, 1]`, the pdf is, ```none pdf(x; n, 0, 1) = ((n / (n-1)!) sum_{k=0}^j (-1)^k (n choose k) (nx - k)^{n-1} ``` where * `total_count = n`, * `j = floor(nx)` * `n!` is the factorial of `n`, * `(n choose k)` is the binomial coefficient `n! / (k!(n - k)!), For arbitrary intervals `[low, high]`, the pdf is, ```none pdf(x; n, low, high) = pdf((x - low) / (high - low); n, 0, 1) / (high - low) ``` #### Examples Create a single distribution for the mean of 5 uniform random variables on the interval `[-10, 5]`. ```python dist = tfd.Bates(total_count=5., low=-10., high=5.) ``` Create a 3-batch of distributions with varying total counts and intervals. ```python counts = [1., 2., 5.] # high will be broadcast to [100., 100., 100.] dist = tfd.Bates(total_count=counts, low=[0., 5., 10.], high=100.) ``` Compute some values for the pdf. ```python dist.probs(50.).eval() # shape: [3] x = [[50., 50., 50.], [5., 10., 20.]] # shape: [2, 3] dist.probs(x).eval() # shape: [2] ``` ççð?FTc s¤ttƒƒ}t |¡†}tj||gtjd}|tjtjfksBtdƒ‚t j |d|d|_ t j ||dd|_ t j ||dd|_ tt|ƒj|tj||||dWd QRXd S) a‡Construct a Bates distribution. Args: total_count: Non-negative integer-valued `Tensor` with shape broadcastable to the batch shape `[N1,..., Nm]`, `m >= 0`. This controls the number of samples of `Uniform(low, high)` to take the mean of. low: Floating point `Tensor` representing the lower bounds of the support. Should be broadcastable to `[N1,..., Nm]` with `m >= 0`, the same dtype as `total_count`, and `low < high` component-wise, after broadcasting. Defaults to `0`. high: Floating point `Tensor` representing the upper bounds of the support. Should be broadcastable to `[N1,..., Nm]` with `m >= 0`, the same dtype as `total_count`, and `low < high` component-wise, after broadcasting. Defaults to `1`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. )Ú dtype_hintz2`Bates` only supports `tf.float32` or `tf.float64`Ú total_count)ÚnamerÚlow)ÚdtyperÚhigh)rZreparameterization_typeÚ validate_argsÚallow_nan_statsÚ parametersrN)ÚdictÚlocalsÚtfZ name_scoper Z common_dtypeÚfloat32Úfloat64ÚAssertionErrorrZconvert_nonref_to_tensorÚ _total_countÚ_lowÚ_highÚsuperrÚ__init__r ZNOT_REPARAMETERIZED) Úselfrrrrrrrr)Ú __class__©úg/home/dcms/DCMS/lib/python3.7/site-packages/tensorflow_probability/python/distributions/_numpy/bates.pyr&~s$   zBates.__init__cCs ttdtj|tjdgdƒƒS)N)rrr)ré)rÚziprÚconvert_to_tensorÚint32)Z sample_shaper)r)r*Ú _param_shapes±szBates._param_shapescCstddddS)Nr)rrr)r)Úclsr)r)r*Ú_params_event_ndims·szBates._params_event_ndimscCs|jS)z6Number of `Uniform` trials used to construct a sample.)r")r'r)r)r*r»szBates.total_countcCs|jS)zLower bound of the support.)r#)r'r)r)r*rÀsz Bates.lowcCs|jS)zUpper bound of the support.)r$)r'r)r)r*rÅsz Bates.highcCsd|jfd|jfd|jfgS)Nrrr)r"r#r$)r'r)r)r*Ú _params_listÊszBates._params_listcCst tjdd„| ¡Dƒ¡S)NcSsg|]\}}t |¡‘qSr))ÚpsÚshape)Ú.0Ú_Úparamr)r)r*ú Òsz-Bates._batch_shape_tensor..)Ú functoolsÚreducer3Úbroadcast_shaper2)r'r)r)r*Ú_batch_shape_tensorÏszBates._batch_shape_tensorcCst tjdd„| ¡Dƒ¡S)NcSsg|]\}}|j‘qSr))r4)r5r6r7r)r)r*r8×sz&Bates._batch_shape..)r9r:rZbroadcast_static_shaper2)r'r)r)r*Ú _batch_shapeÔszBates._batch_shapecCstjgtjdS)N)r)rZconstantr.)r'r)r)r*Ú_event_shape_tensorÙszBates._event_shape_tensorcCs t g¡S)N)rZ TensorShape)r'r)r)r*Ú _event_shapeÜszBates._event_shapeNcCsFt |jtj¡}t |j¡}t |j¡}tt  ||  ¡¡||||dS)N)Úseed) rÚcastrr.r-rrÚ _sample_batesr3Ú broadcast_tor<)r'Únr@rrrr)r)r*Ú _sample_nßs   zBates._sample_ncCst|j|j|j|j|ƒS)N)Ú _bates_pdfrrrr)r'Úvaluer)r)r*Ú_probçsz Bates._probcCst|j|j|j|j|ƒS)N)Ú _bates_cdfrrrr)r'rGr)r)r*Ú_cdfêsz Bates._cdfcCs|j|jdS)Ng@)rr)r'r)r)r*Ú_meanísz Bates._meanzGFor `n = 1`, any value in `(low, high)` is a mode; this gives the mean.cCs| ¡S)N)rK)r'r)r)r*Ú_modeðsz Bates._modecCs(tj |j|j¡dt |j|j¡S)Ng(@)rÚmathZsquarerrrArr)r'r)r)r*Ú _varianceõszBates._variancecCstj|j|j|jdS)N)rrr)Úsigmoid_bijectorZSigmoidrrr)r'r)r)r*Ú_default_event_space_bijectorùsz#Bates._default_event_space_bijectorc Cs |js gS|rZy | ¡Wn>tk rXtd t |j¡t |j¡t |j¡¡ƒ‚YnXg}|t   |j¡krÎt  |j¡}t |j }| tj|ddtj|ddtjt ||j ¡t ||j ¡d |¡dg¡|t   |j¡pæt   |j¡kr| tj|j|jdd¡|S)NzyArguments `total_count`, `low` and `high` must have compatible shapes; total_count.shape={}, low.shape={}, high.shape={}.z`total_count` must be positive.)Úmessagez%`total_count` must be integer-valued.z+`total_count` > {} is numerically unstable.z`low` must be less than `high`.)rr=Ú ValueErrorÚformatrr4rrrrZis_refr-Ú"BATES_TOTAL_COUNT_STABILITY_LIMITSrÚextendr Zassert_positiver Zassert_integer_formZassert_less_equalrAÚappendZ assert_less)r'Zis_initZ assertionsrÚlimitr)r)r*Ú_parameter_control_dependenciesýs@       z%Bates._parameter_control_dependencies)rrFTr)N)Ú__name__Ú __module__Ú __qualname__Ú__doc__r&Ú staticmethodr/Ú classmethodr1Úpropertyrrrr2r<r=r>r?rErHrJrKr ZAppendDocstringrLrNrPrXÚ __classcell__r)r))r(r*r=s2?-      c Csöt ||¡}t |¡}t |¡}t t||ƒg¡¸||}|||}t |dd¡}t |dk|d|¡}t tj |¡||¡}t   t   |¡t   |¡¡}t   ||¡} ||} t  | dg¡} t  | dg¡} tjtj | d¡tjd} t t| ƒ|¡}t | | ¡}t | | ¡}t d|¡|d|dtj t ||d|d¡¡|||d}t t t | ¡¡| ¡}tj ||¡}t  ||¡}|| |tj tj | ¡¡}t |dk|dkBt d|¡|¡}t tj |¡|tj¡}|SQRXdS) aèCompute the Bates pdf. Internally, the (standard, unnormalized) pdf is computed by the formula ```none pdf = sum_{k=0}^j (-1)^k (n choose k) (nx - k)^{n - 1} ``` where * `n = total_count`, * `x = value` the value to compute the probability of, and * `j = floor(nx)`. This is shifted to `[low, high]` and normalized. Since the pdf is symmetric, we only compute the left half, which keeps the number of terms lower. Computation is batched, using `tf.math.segment_sum()`. For this reason this is not compatible with `tf.vectorized_map()`. All input parameters should have compatible dtypes and shapes. Args: total_count: `Tensor` with integer values, as given to the `Bates` constructor. low: Float `Tensor`, as given to the `Bates` constructor. high: Float `Tensor`, as given to the `Bates` constructor. dtype: The dtype of the output. value: Float `Tensor`. Input value to `prob()`. Returns: pdf: Float `Tensor`. See above formula. ggð?gà?éÿÿÿÿé)rgð¿N)rrAr-Úcontrol_dependenciesÚ_stability_limit_tensorÚ clip_by_valueÚwhererMÚ is_finiter3r;r4rCÚreshapeÚfloorr.Ú_segmented_rangeÚrepeatÚexpÚtfp_mathÚlbetaÚrangeÚsizeÚ segment_sumÚlgammaÚnpÚnan)rrrrrGZrange_Úvalue_centeredÚ value_adjr4Ú total_count_bÚtotal_count_x_value_adj_bÚ total_count_fÚtotal_count_x_value_adj_fÚ num_terms_fÚ term_idx_sÚ total_count_sÚtotal_count_x_value_adj_sÚtermsÚ segment_idsZpdf_sZpdfr)r)r*rF)s<       L rFc Cst ||¡}t |¡}t |¡}t t||ƒg¡Ü||||}t |dd¡}t |dk|d|¡}t tj |¡||¡}t   t   |¡t   |¡¡}t   ||¡}||} t  |dg¡} t  | dg¡} tjtj | d¡tjd} t t| ƒ|¡} t | | ¡}t | | ¡}t d|¡| d|dtj t || d| d¡¡|| |}t t t | ¡¡| ¡}tj ||¡}t  ||¡}|tj tj |t d|¡¡¡}t |dkd||¡}t |dkt d|¡|¡}t |dkt d|¡|¡}t tj |¡|tj¡}|SQRXdS) a$Compute the Bates cdf. Internally, the (standard, unnormalized) cdf is computed by the formula ```none pdf = sum_{k=0}^j (-1)^k (n choose k) (nx - k)^n ``` where * `n = total_count`, * `x = value` the value to compute the cumulative probability of, and * `j = floor(nx)`. This is shifted to `[low, high]` and normalized. Since the pdf is symmetric, we have `cdf(x) = 1 - cdf(1 - x)` for `x > .5`, hence we only compute the left half, which keeps the number of terms lower. Computation is batched, using `tf.math.segment_sum()`. For this reason this is not compatible with `tf.vectorized_map()`. All input parameters should have compatible dtypes and shapes. Args: total_count: `Tensor` with integer values, as given to the `Bates` constructor. low: Float `Tensor`, as given to the `Bates` constructor. high: Float `Tensor`, as given to the `Bates` constructor. dtype: The dtype of the output. value: Float `Tensor`. Input value to `cdf()`. Returns: cdf: Float `Tensor`. See above formula. ggð?gà?rarb)rgð¿N)rrAr-rcrdrerfrMrgr3r;r4rCrhrir.rjrkrlrmrnrorprqrrrsrt)rrrrrGrurvr4rwrxryrzr{r|r}r~rr€Zcdf_sZcdfr)r)r*rI{s:!      H $rIcs4t t||¡‰t tj |ˆk¡‡fdd„tj¡S)NcstjdˆtjdS)Nz6WARNING: Bates PDF/CDF is unstable for `total_count` >)Z output_stream)rÚprintÚsysÚstderrr))rWr)r*ÚÒsz)_stability_limit_tensor..)rrArTZcondrMZ reduce_anyZno_op)rrr))rWr*rdÍs  rdc Cs:t t |¡¡t tjdgt |dd…¡gdd|¡S)zàEquivalent to `tf.ragged.range(limits).flat_values`. Ragged Tensors are are not supported by numpy. Args: limits: Integer `Tensor` of sizes of each range. Returns: segments: 1D `Tensor` of segment ranges. rNra)Úaxis)rroÚ reduce_sumrkÚconcatZcumsum)Zlimitsr)r)r*rjØs rjcCsÄtjt |¡g|ggdd}tj|dd|j|d}t |dg¡}t t t  |¡¡|¡}tj   ||¡} tjt  |¡|ggdd} t | | ¡} t t  | ¡¡} t | tj| ddd¡} |||| S) a:Vectorized production of `Bates` samples. Args: total_count: (Batches of) counts of `Uniform`s to take means of. Should have integer dtype and already be broadcasted to the batch shape. low: (Batches of) lower bounds of the `Uniform` variables to sample. Should be the same floating dtype as `high` and broadcastable to the batch shape. high: (Batches of) upper bounds of the `Uniform` variables to sample. Should be the same floating dtype as `low` and broadcastable to the batch shape. n: `int32` number of samples to generate. seed: Random seed to pass to `Uniform` sampler. Returns: samples: Samples of (batches of) the `Bates` variable. Will have same dtype as `low` and `high`. If the batch shape is `[B1,..., Bn]`, `samples` has shape `[n, B1,..., Bn]`. r)r…ggð?)ÚminvalÚmaxvalrr@rarb)Úshiftr…)rr‡r†rÚuniformrrhrkrorprMZ segment_meanr4ZrankZ transposeZroll)rrrrDr@Zuniform_sample_shapeZuniform_samplesZsegment_lengthsr€Z flatmeansZoutshapeZtmeansZaxesZmeansr)r)r*rBès rB)N),r\Ú __future__rrrr9r‚ÚnumpyrsZ;tensorflow_probability.python.internal.backend.numpy.compatrrZ"tensorflow_probability.python.mathrrmZ.tensorflow_probability.python.bijectors._numpyrrOZ2tensorflow_probability.python.distributions._numpyrZ-tensorflow_probability.python.internal._numpyr r r r r3Z&tensorflow_probability.python.internalr rrÚ__all__r ZfinforrÚfloat16rTÚ DistributionrrFrIrdrjrBr)r)r)r*ÚsD              mRR