B `1F@s2dZddlmZddlmZddlmZddlZddlmZ ddl m Z ddl m Z dd l mZdd l mZdd l mZdd l mZdd lmZddl mZddl mZdgZdde jddfddZdde jddfddZe jdddde jddfddZGddde jZe jdfddZ e jdfddZ!dS)zThe Poisson distribution class.)absolute_import)division)print_functionN)v2) distribution) assert_util)batched_rejection_sampler)distribution_util) dtype_util)implementation_selection)reparameterization)samplers) tensor_utilPoissonc CsZt|p dB|dkr$tj|}tj|t|gdd}tjj||||dSQRXdS)z2Sample using *fast* `tf.random.stateless_poisson`.Z poisson_cpuNr)axis)shapeseedZlamdtype)tf name_scopemathexpconcatrrandomZstateless_poisson)rrates log_rates output_dtypernameri/home/dcms/DCMS/lib/python3.7/site-packages/tensorflow_probability/python/distributions/_numpy/poisson.py_random_poisson_cpu's  r c Cs t|p d|dkr$tj|}tj|t|gdd}tj|}tj}t |\}} ||t dk@} t ||} t | | d} t || || d} t | |} || @}t |tj| d}t||||d }t ||}t |t | | |t j}WdQRX|S) z9Sample using XLA-friendly python-based rejection sampler.Zpoisson_noncpuNr)rg$@gY@)log_rateinternal_dtypergh㈵>)rater"r)rrrlogrris_nanfloat64r split_seednpcastwhere_random_poisson_high_rater_random_poisson_low_ratenan)rrrrrrZgood_params_maskr"Zseed_loZseed_hiZhigh_params_maskZcast_log_ratesZsafe_log_ratesZhigh_rate_samplesZlow_params_maskZ safe_rateZlow_rate_samplessamplesrrr_random_poisson_noncpu7s2     r/F)Z autographc Csdt|p dLt|}tj|tjdd}t||||||d}tjdt t d}|f|SQRXdS)a*Sample a poisson, CPU specialized to stateless_poisson. Args: shape: Shape of the full sample output. Trailing dims should match the broadcast shape of `counts` with `probs|logits`. rates: Batch of rates for Poisson distribution. log_rates: Batch of log rates for Poisson distribution. output_dtype: DType of samples. seed: int or Tensor seed. name: Optional name for related ops. Returns: samples: Samples from poisson distributions. runtime_used_for_sampling: One of `implementation_selection._RUNTIME_*`. Zrandom_poissonr) dtype_hintr)rrrrrrZpoisson)fn_nameZ default_fnZcpu_fnN) rrr sanitize_seedconvert_to_tensorint32dictr Zimplementation_selectingr/r )rrrrrrparamsZ sampler_implrrr_random_poissonfs  r7cseZdZdZd8fdd ZeddZed d Zed d Z ed dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zed%d&d'Zd9d(d)Zd:d*d+Zd,d-Zd;d.d/Zd0d1Zd2d3Zd4d5Zd6d7Z Z!S)= 0) = (lambda^k / k!) / Z Z = exp(lambda). ``` where `rate = lambda` and `Z` is the normalizing constant. NTFc stt}|dk|dkkr"tdt|}tj||gtjd}t|s`t d t |t j |d|d|_t j |d|d|_||_tt|j|tj||||dWdQRXdS) a4Initialize a batch of Poisson distributions. Args: rate: Floating point tensor, the rate parameter. `rate` must be positive. Must specify exactly one of `rate` and `log_rate`. log_rate: Floating point tensor, the log of the rate parameter. Must specify exactly one of `rate` and `log_rate`. interpolate_nondiscrete: Python `bool`. When `False`, `log_prob` returns `-inf` (and `prob` returns `0`) for non-integer inputs. When `True`, `log_prob` evaluates the continuous function `k * log_rate - lgamma(k+1) - rate`, which matches the Poisson pmf at integer arguments `k` (note that this function is not itself a normalized probability log-density). Default value: `True`. validate_args: Python `bool`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. Default value: `False`. allow_nan_stats: Python `bool`. 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. Default value: `True`. name: Python `str` name prefixed to Ops created by this class. Raises: ValueError: if none or both of `rate`, `log_rate` are specified. TypeError: if `rate` is not a float-type. TypeError: if `log_rate` is not a float-type. Nz2Must specify exactly one of `rate` and `log_rate`.)r0z,[log_]rate.dtype ({}) is a not a float-type.r#)rrr!)rZreparameterization_type validate_argsallow_nan_stats parametersr)r5locals ValueErrorrrr Z common_dtypefloat32Z is_floating TypeErrorformatrrZconvert_nonref_to_tensor_rate _log_rate_interpolate_nondiscretesuperr__init__r ZNOT_REPARAMETERIZED) selfr#r!interpolate_nondiscreter8r9rr:r) __class__rrrDs(&    zPoisson.__init__cCs tdddS)Nr)r#r!)r5)clsrrr_params_event_ndimsszPoisson._params_event_ndimscCs|jS)zRate parameter.)r@)rErrrr#sz Poisson.ratecCs|jS)zLog rate parameter.)rA)rErrrr!szPoisson.log_ratecCs|jS)z.Interpolate (log) probs on non-integer inputs.)rB)rErrrrFszPoisson.interpolate_nondiscretecCs |jdkr|jn|j}t|S)N)rAr@rr)rExrrr_batch_shape_tensorszPoisson._batch_shape_tensorcCs|jdkr|jn|j}|jS)N)rAr@r)rErJrrr _batch_shapeszPoisson._batch_shapecCstjgtjdS)N)r)rZconstantr4)rErrr_event_shape_tensorszPoisson._event_shape_tensorcCs tgS)N)rZ TensorShape)rErrr _event_shapeszPoisson._event_shapecCsN|}|||||}|jsJttj|t |j t j |}|S)N) _log_rate_parameter_no_checks_log_unnormalized_prob_log_normalizationrFrr*rZis_infr as_numpy_dtyperr(inf)rErJr!Z log_probsrrr _log_probs   zPoisson._log_probcCstj||S)N)rrr$cdf)rErJrrr_log_cdfszPoisson._log_cdfcCsJt|jr|nt|d}tjd||}t|dkt||S)Ngg?) rmaximumrFfloorrZigammac_rate_parameter_no_checksr*Z zeros_like)rErJsafe_xrUrrr_cdfsz Poisson._cdfcCs t|S)N)rr)rEr!rrrrQszPoisson._log_normalizationcCs`t|jr|nt|d}tj||tjd|}tt|||t |j t j S)Ngg?)rrWrFrXrZmultiply_no_nanlgammar*equalr rRrr(rS)rErJr!rZyrrrrPszPoisson._log_unnormalized_probcCs|S)N)rY)rErrr_meansz Poisson._meancCs|S)N)rY)rErrr _varianceszPoisson._variancezNote: when `rate` is an integer, there are actually two modes: `rate` and `rate - 1`. In this case we return the larger, i.e., `rate`.cCst|S)N)rrXrY)rErrr_mode!sz Poisson._modecCsVt|}tt|g|jdkr$dn t|j|jdkr|t|jkr>|tj|jdd|S)Nz%Argument `rate` must be non-negative.)message)r8r@rZis_refappendrZassert_non_negative)rEZis_init assertionsrrr_parameter_control_dependenciesIs  z'Poisson._parameter_control_dependenciescCs"g}|js|S|t||S)N)r8extendr Zassert_nonnegative_integer_form)rErJrkrrr_sample_control_dependenciesTs z$Poisson._sample_control_dependencies)NNTFTr)N)N)N)"__name__ __module__ __qualname____doc__rD classmethodrIpropertyr#r!rFrKrLrMrNrTrVr[rQrPr_r`r ZAppendDocstringrarcrdrYrgrOrhrlrn __classcell__rr)rGrrs@6         csntjddtjddddddfd d }tj||d d }|S) aSamples from the Poisson distribution using transformed rejection sampling. Given a CDF F(x), and G(x), a dominating distribution chosen such that it is close to the inverse CDF F^-1(x), compute the following steps: 1) Generate U and V, two independent random variates. Set U = U - 0.5 (this step isn't strictly necessary, but is done to make some calculations symmetric and convenient. Henceforth, G is defined on [-0.5, 0.5]). 2) If V <= alpha * F'(G(U)) * G'(U), return floor(G(U)), else return to step 1. alpha is the acceptance probability of the rejection algorithm. The dominating distribution in this case: G(u) = (2 * a / (2 - |u|) + b) * u + c For more details on transformed rejection, see [1]. Args: sample_shape: The output sample shape. Must broadcast with `log_rate`. log_rate: Floating point tensor, log rate. internal_dtype: dtype to use for internal computations. seed: (optional) The random seed. Returns: Samples from the poisson distribution using transformed rejection. #### References [1]: W. Hormann, G. Derflinger, The Transformed Rejection Method For Generating Random Variables, An Alternative To The Ratio Of Uniforms Method (1994), Manuskript, Institut f. Statistik, Wirtschaftsuniversitat gn?g= ףp=@g?gh|?5g[ m?g$~?gr?g333333 @c st|\}}tj|d}|d}dtj|}tj|d}tjd||d}|dk|dddk@}tj|tj|} |tj |d} ||| kB}||d k@|d k||kB@}||fS) zGenerate and test samples.)rrg?g@gQ?gQ?gr鷯?gB>٬ @rg9v?) r r'uniformrrabsrXr$Zsquarer\) ru_seedZv_seeduZ u_shiftedvkZgood_sample_maskst)abr" inverse_alphar!r# sample_shaperrgenerate_and_test_sampless$$  z<_random_poisson_high_rate..generate_and_test_samples)rr)rrrbrsZbatched_las_vegas_algorithm)rr!r"rrr.r)rrr"rr!r#rrr+\s#  r+c sztj| fdd}tjdd|tjtjdtjtjdtjdtjgtjd|gdd\}}}}}|S)aSamples from the Poisson distribution using Knuth's algorithm. We use an algorithm attributed to Knuth: Seminumerical Algorithms. Art of Computer Programming, Volume 2. This algorithm runs in O(rate) time, and requires O(rate) uniform variates. This algorithm is performant for rate ~<10. Given a Poisson process, the time between events is exponentially distributed. If we have a Poisson process with rate lambda, then, the time between events is distributed as Exp(lambda). If X ~ Uniform(0, 1), then Y ~ Exp(lambda) where Y = -log(X) / lambda. Thus, to simulate a Poisson draw, we can sample X_i ~ Exp(lambda), and we will haver N ~ Poisson(lambda), where N is the smallest number such that sum_i^N X_i > 1. Args: sample_shape: The output sample shape. Must broadcast with `rate`. rate: Floating point tensor, rate. internal_dtype: (optional) dtype to use for internal computations. seed: (optional) The random seed. Returns: Samples from the poisson distribution. csTt|\}}|tj|d}||k@}t|||}||@|||d|gS)N)rrrv)r r'rwrr*)should_continuer.prodZ num_itersrryZ next_seedaccept) exp_neg_rater"rrr loop_bodys  z+_random_poisson_low_rate..loop_bodycWs t|S)N)rZ reduce_any)rignorerrrz*_random_poisson_low_rate..)r)ZcondbodyZ loop_varsZmaximum_iterations)rrrZ while_loopZonesboolzerosr4)rr#r"rr_r.r)rr"rrr,s  r,)"rr __future__rrrnumpyr(Z;tensorflow_probability.python.internal.backend.numpy.compatrrZ2tensorflow_probability.python.distributions._numpyrZ-tensorflow_probability.python.internal._numpyrrrr r r Z&tensorflow_probability.python.internalr r r__all__r=r r/functionr7 Distributionrr&r+r,rrrrsJ               ) V E