B `iS@s~dZddlmZddlmZddlmZddlZddlmZ ddl m Z ddl m ZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZdZddZd,ddZ dde j!ddfddZ"dde j!ddfddZ#e j$dddde j!ddfd d!Z%Gd"d#d#ej&Z'd$d%Z(d&d'Z)d(d)Z*d*d+Z+dS)-z The Binomial distribution class.)absolute_import)division)print_functionN)v2)_numpy) distribution) exponential) assert_util)batched_rejection_sampler)distribution_util) dtype_util)implementation_selection) prefer_static)reparameterization)samplers) tensor_util)tensorshape_utila5 For each batch member of counts `value`, `P[value]` is the probability that after sampling `self.total_count` draws from this Binomial distribution, the number of successes is `value`. Since different sequences of draws can result in the same counts, the probability includes a combinatorial coefficient. Note: `value` must be a non-negative tensor with dtype `dtype` and whose shape can be broadcast with `self.probs` and `self.total_count`. `value` is only legal if it is less than or equal to `self.total_count` and its components are equal to integer values. cCsTt||}t||}t||||}tjj||dd|d}t|||S)zThe binomial cumulative distribution function. Args: k: floating point `Tensor`. n: floating point `Tensor`. p: floating point `Tensor`. Returns: `sum_{j=0}^k p^j (1 - p)^(n - j)`. )abx)tfZ ones_likeequalwheremathZbetainc)knpZonesZk_eq_nZsafe_dnZdkrj/home/dcms/DCMS/lib/python3.7/site-packages/tensorflow_probability/python/distributions/_numpy/binomial.py_bdtr5s  r rc sttj|tgddtdd d tjtjddddkrxttj dkrttj  fd d }fd d }t t j |||ddS) aUtility for rejection sampling from log-concave discrete distributions. This utility constructs an easy-to-sample-from upper bound for a discrete univariate log-concave distribution (for discrete univariate distributions, a necessary and sufficient condition is p_k^2 >= p_{k-1} p_{k+1} for all k). The method requires that the mode of the distribution is known. While a better method can likely be derived for any given distribution, this method is general and easy to implement. The expected number of iterations is bounded by 4+m, where m is the probability of the mode. For details, see [(Devroye, 1979)][1]. Args: mode: Tensor, the mode[s] of the [batch of] distribution[s]. prob_fn: Python callable, counts -> prob(counts). dtype: DType of the generated samples. sample_shape: 0D or 1D `int32` `Tensor`. Shape of the generated samples. distribution_minimum: Tensor of type `dtype`. The minimum value taken by the distribution. The `prob` method will only be called on values greater than equal to the specified minimum. The shape must broadcast with the batch shape of the distribution. If unspecified, the domain is treated as unbounded below. distribution_maximum: Tensor of type `dtype`. The maximum value taken by the distribution. See `distribution_minimum` for details. seed: Python integer or `Tensor` instance, for seeding PRNG. Returns: samples: a `Tensor` with prepended dimensions `sample_shape`. #### References [1] Luc Devroye. A Simple Generator for Discrete Log-Concave Distributions. Computing, 1987. [2] Dillon et al. TensorFlow Distributions. 2017. https://arxiv.org/abs/1711.10604 r)axisg?g@r)dtype)ZrateNcstj|ddd\}}}}tj|d}|}j|d}|}|} tj|d} t| } t| || } tt j |d| } | }t| |}||fS)z+Proposal for log-concave rejection sampler.Z&log_concave_rejection_sampler_proposal)rsalt)seedr")r%) rZ split_seeduniformsampleprobrZ less_equalrround tfp_randomZ rademacher)r%Ztop_lobe_fractions_seedZexponential_samples_seedZtop_selector_seedZrademacher_seedZtop_lobe_fractionsZ top_offsetsZexponential_samplesZexponential_heightZexponential_offsetsZ top_selectorZ on_top_maskZunsigned_offsetsoffsetsZpotential_samplesZenvelope_height)r"exponential_distributionmode mode_height mode_shape top_fraction top_widthrrproposals*       z0_log_concave_rejection_sampler..proposalcs0|k|k@}t||d}t||dS)Ng)rr)valuesZ in_range_maskZin_range_values)distribution_maximumdistribution_minimumprob_fnrrtargetsz._log_concave_rejection_sampler..target) rZ broadcast_toconcatrshaperZ ExponentialconstantnpinfZ stop_gradientr ) r-r6r" sample_shaper5r4r%r2r7r) r4r5r"r,r-r.r/r6r0r1r_log_concave_rejection_samplerKs",   !r>c Cs|t|p dd|dkr2t|dktj|d}tt|t|}tjj tj ||gdd||||d}WdQRX|S)z3Sample using *fast* `tf.random.stateless_binomial`.Z binomial_cpuNr)r!)r9r%countsprobs output_dtype) r name_scoperrsigmoidrZbroadcast_shaper9randomZstateless_binomialr8) r9r?r@logitsrAr%nameZ batch_shapesamplesrrr_random_binomial_cpus  rHc Csbt|p dJt|||d}t||j|j|tjd|jd||d}t||}WdQRX|S)z9Sample using XLA-friendly python-based rejection sampler.Zbinomial_noncpu) total_countrEr@r)r")r6r"r=r5r4r%N) rrBBinomialr>r-r(r"zeroscast) r9r?r@rErAr%rFdistrGrrr_random_binomial_noncpus  rNF)Z autographc Csft|p dNt|}tj|tjdd}t|||||||d}tjdt t d}|f|SQRXdS)a'Sample a binomial, CPU specialized to stateless_binomial. Args: shape: Shape of the full sample output. Trailing dims should match the broadcast shape of `counts` with `probs|logits`. counts: Batch of total_count. probs: Batch of p(success). logits: Batch of log-odds(success). output_dtype: DType of samples. seed: int or Tensor seed. name: Optional name for related ops. Returns: samples: Samples from binomial distributions. runtime_used_for_sampling: One of `implementation_selection._RUNTIME_*`. Zrandom_binomialr9)Z dtype_hintrF)r9r?r@rErAr%rFbinomial)fn_nameZ default_fnZcpu_fnN) rrBr sanitize_seedconvert_to_tensorint32dictr Zimplementation_selectingrNrH) r9r?r@rErAr%rFparamsZ sampler_implrrr_random_binomials   rVcseZdZdZd4fdd ZeddZed d Zed d Z ed dZ ddZ ddZ ddZ ddZeeddZeeddZddZeed5ddZd6dd Zd!d"Zed#d$d%Zd7d&d'Zd(d)Zd8d*d+Zd9d,d-Zd.d/Zd0d1Zd2d3ZZ S):rJa9Binomial distribution. This distribution is parameterized by `probs`, a (batch of) probabilities for drawing a `1`, and `total_count`, the number of trials per draw from the Binomial. #### Mathematical Details The Binomial is a distribution over the number of `1`'s in `total_count` independent trials, with each trial having the same probability of `1`, i.e., `probs`. The probability mass function (pmf) is, ```none pmf(k; n, p) = p**k (1 - p)**(n - k) / Z Z = k! (n - k)! / n! ``` where: * `total_count = n`, * `probs = p`, * `Z` is the normalizing constant, and, * `n!` is the factorial of `n`. #### Examples Create a single distribution, corresponding to 5 coin flips. ```python dist = Binomial(total_count=5., probs=.5) ``` Create a single distribution (using logits), corresponding to 5 coin flips. ```python dist = Binomial(total_count=5., logits=0.) ``` Creates 3 distributions with the third distribution most likely to have successes. ```python p = [.2, .3, .8] # n will be broadcast to [4., 4., 4.], to match p. dist = Binomial(total_count=4., probs=p) ``` The distribution functions can be evaluated on counts. ```python # counts same shape as p. counts = [1., 2, 3] dist.prob(counts) # Shape [3] # p will be broadcast to [[.2, .3, .8], [.2, .3, .8]] to match counts. counts = [[1., 2, 1], [2, 2, 4]] dist.prob(counts) # Shape [2, 3] # p will be broadcast to shape [5, 7, 3] to match counts. counts = [[...]] # Shape [5, 7, 3] dist.prob(counts) # Shape [5, 7, 3] ``` NFTc stt}|dk|dkkr"tdt|p,dn}t|||gtj}tj ||dd|_ tj ||dd|_ tj ||dd|_ t t|j|tj||||dWdQRXdS) aRInitialize a batch of Binomial distributions. Args: total_count: Non-negative floating point tensor with shape broadcastable to `[N1,..., Nm]` with `m >= 0` and the same dtype as `probs` or `logits`. Defines this as a batch of `N1 x ... x Nm` different Binomial distributions. Its components should be equal to integer values. logits: Floating point tensor representing the log-odds of a positive event with shape broadcastable to `[N1,..., Nm]` `m >= 0`, and the same dtype as `total_count`. Each entry represents logits for the probability of success for independent Binomial distributions. Only one of `logits` or `probs` should be passed in. probs: Positive floating point tensor with shape broadcastable to `[N1,..., Nm]` `m >= 0`, `probs in [0, 1]`. Each entry represents the probability of success for independent Binomial distributions. Only one of `logits` or `probs` should be passed in. 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. Nzt|}tjtj| | tjtj|||S)z)Log unnormalized probability from logits.)rrRrmultiply_no_nanZsoftplus)rEr?rIrrrrjs rjcCs<t|}tjtj||tjtj| ||S)z(Log unnormalized probability from probs.)rrRrrr{r|)r@r?rIrrrrk#s rkcCs(td|d||tjd|S)Ng?)tfp_mathZlbetarrr{)r?rIrrrrl+srlcCsLt|jr(t|jr(t|j|jsD|t|}|t|}||fS)N)rZis_fully_definedr9Zis_compatible_withrZ zeros_like)rrrrrrq0s   rq)rNNN),r __future__rrrnumpyr;Z;tensorflow_probability.python.internal.backend.numpy.compatrrZ"tensorflow_probability.python.mathrrZ$tensorflow_probability.python.randomr*Z2tensorflow_probability.python.distributions._numpyrrZ-tensorflow_probability.python.internal._numpyr r r r r rZ&tensorflow_probability.python.internalrrrrrr r>r\rHrNfunctionrV DistributionrJrjrkrlrqrrrrs`                   d