o ?eY5@sdZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd l m Z dd l m Zdd lmZdd lmZdgZdZedgdGddde jZdS)z,The DirichletMultinomial distribution class.)dtypes)ops) array_ops) check_ops)control_flow_ops)math_ops) random_ops)special_math_ops) distribution)util) deprecation) tf_exportDirichletMultinomialaFor each batch of counts, `value = [n_0, ..., n_{K-1}]`, `P[value]` is the probability that after sampling `self.total_count` draws from this Dirichlet-Multinomial distribution, the number of draws falling in class `j` is `n_j`. Since this definition is [exchangeable](https://en.wikipedia.org/wiki/Exchangeable_random_variables); different sequences have the same counts so the probability includes a combinatorial coefficient. Note: `value` must be a non-negative tensor with dtype `self.dtype`, have no fractional components, and such that `tf.reduce_sum(value, -1) = self.total_count`. Its shape must be broadcastable with `self.concentration` and `self.total_count`.z"distributions.DirichletMultinomial)v1cseZdZdZejdddd   d+fdd Zed d Zed d Z ed dZ ddZ ddZ ddZ ddZd,ddZeeddZeeddZddZed d!d"Zd#d$Zd%d&Zd'd(Zd)d*ZZS)-raX Dirichlet-Multinomial compound distribution. The Dirichlet-Multinomial distribution is parameterized by a (batch of) length-`K` `concentration` vectors (`K > 1`) and a `total_count` number of trials, i.e., the number of trials per draw from the DirichletMultinomial. It is defined over a (batch of) length-`K` vector `counts` such that `tf.reduce_sum(counts, -1) = total_count`. The Dirichlet-Multinomial is identically the Beta-Binomial distribution when `K = 2`. #### Mathematical Details The Dirichlet-Multinomial is a distribution over `K`-class counts, i.e., a length-`K` vector of non-negative integer `counts = n = [n_0, ..., n_{K-1}]`. The probability mass function (pmf) is, ```none pmf(n; alpha, N) = Beta(alpha + n) / (prod_j n_j!) / Z Z = Beta(alpha) / N! ``` where: * `concentration = alpha = [alpha_0, ..., alpha_{K-1}]`, `alpha_j > 0`, * `total_count = N`, `N` a positive integer, * `N!` is `N` factorial, and, * `Beta(x) = prod_j Gamma(x_j) / Gamma(sum_j x_j)` is the [multivariate beta function]( https://en.wikipedia.org/wiki/Beta_function#Multivariate_beta_function), and, * `Gamma` is the [gamma function]( https://en.wikipedia.org/wiki/Gamma_function). Dirichlet-Multinomial is a [compound distribution]( https://en.wikipedia.org/wiki/Compound_probability_distribution), i.e., its samples are generated as follows. 1. Choose class probabilities: `probs = [p_0,...,p_{K-1}] ~ Dir(concentration)` 2. Draw integers: `counts = [n_0,...,n_{K-1}] ~ Multinomial(total_count, probs)` The last `concentration` dimension parametrizes a single Dirichlet-Multinomial distribution. When calling distribution functions (e.g., `dist.prob(counts)`), `concentration`, `total_count` and `counts` are broadcast to the same shape. The last dimension of `counts` corresponds single Dirichlet-Multinomial distributions. Distribution parameters are automatically broadcast in all functions; see examples for details. #### Pitfalls The number of classes, `K`, must not exceed: - the largest integer representable by `self.dtype`, i.e., `2**(mantissa_bits+1)` (IEE754), - the maximum `Tensor` index, i.e., `2**31-1`. In other words, ```python K <= min(2**31-1, { tf.float16: 2**11, tf.float32: 2**24, tf.float64: 2**53 }[param.dtype]) ``` Note: This condition is validated only when `self.validate_args = True`. #### Examples ```python alpha = [1., 2., 3.] n = 2. dist = DirichletMultinomial(n, alpha) ``` Creates a 3-class distribution, with the 3rd class is most likely to be drawn. The distribution functions can be evaluated on counts. ```python # counts same shape as alpha. counts = [0., 0., 2.] dist.prob(counts) # Shape [] # alpha will be broadcast to [[1., 2., 3.], [1., 2., 3.]] to match counts. counts = [[1., 1., 0.], [1., 0., 1.]] dist.prob(counts) # Shape [2] # alpha will be broadcast to shape [5, 7, 3] to match counts. counts = [[...]] # Shape [5, 7, 3] dist.prob(counts) # Shape [5, 7] ``` Creates a 2-batch of 3-class distributions. ```python alpha = [[1., 2., 3.], [4., 5., 6.]] # Shape [2, 3] n = [3., 3.] dist = DirichletMultinomial(n, alpha) # counts will be broadcast to [[2., 1., 0.], [2., 1., 0.]] to match alpha. counts = [2., 1., 0.] dist.prob(counts) # Shape [2] ``` z 2019-01-01zThe TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.distributions`.T)Z warn_onceFc stt}tj|||gd-}tj|dd|_|r t|j|_|tj|dd||_ t |j d|_ Wdn1s>wYt t|j|j j||tj||j|j g|ddS)aInitialize a batch of DirichletMultinomial distributions. Args: total_count: Non-negative floating point tensor, whose dtype is the same as `concentration`. The shape is broadcastable to `[N1,..., Nm]` with `m >= 0`. Defines this as a batch of `N1 x ... x Nm` different Dirichlet multinomial distributions. Its components should be equal to integer values. concentration: Positive floating point tensor, whose dtype is the same as `n` with shape broadcastable to `[N1,..., Nm, K]` `m >= 0`. Defines this as a batch of `N1 x ... x Nm` different `K` class Dirichlet multinomial distributions. 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. )values total_count)name concentrationN)dtype validate_argsallow_nan_statsZreparameterization_type parametersZ graph_parentsr)dictlocalsrZ name_scopeZconvert_to_tensor _total_countdistribution_util$embed_check_nonnegative_integer_form!_maybe_assert_valid_concentration_concentrationr reduce_sum_total_concentrationsuperr__init__rr ZNOT_REPARAMETERIZED)selfrrrrrr __class__z/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/distributions/dirichlet_multinomial.pyr#s6 $   zDirichletMultinomial.__init__cC|jS)z,Number of trials used to construct a sample.)rr$r'r'r(rz DirichletMultinomial.total_countcCr))zCConcentration parameter; expected prior counts for that coordinate.)rr*r'r'r(rr+z"DirichletMultinomial.concentrationcCr))z+Sum of last dim of concentration parameter.)r!r*r'r'r(total_concentrationr+z(DirichletMultinomial.total_concentrationcCs t|jSN)rshaper,r*r'r'r(_batch_shape_tensors z(DirichletMultinomial._batch_shape_tensorcCs |jSr-)r, get_shaper*r'r'r( _batch_shapes z!DirichletMultinomial._batch_shapecCst|jddS)Nr)rr.rr*r'r'r(_event_shape_tensorsz(DirichletMultinomial._event_shape_tensorcCs|jdddS)Nr)rr0Zwith_rank_at_leastr*r'r'r( _event_shapesz!DirichletMultinomial._event_shapeNc Cstj|jtjd}|d}tjtt j |g|j |j |dd|gd}t j ||tj|ddd}ttj||d d }t|g||ggd}t||}t||j S) N)rr)r.alpharseedr)r.Zdirichlet_multinomial)salt)ZlogitsZ num_samplesr6)depth)rcastrrZint32Zevent_shape_tensorrZreshapelogrZ random_gammarrZ multinomialrZ gen_new_seedr Zone_hotconcatZbatch_shape_tensor) r$nr6Zn_drawskZunnormalized_logitsZdrawsxZ final_shaper'r'r( _sample_ns(   zDirichletMultinomial._sample_ncCs8||}t|j|t|j}|t|j|Sr-)_maybe_assert_valid_sampler ZlbetarrZlog_combinationsr)r$countsZ ordered_probr'r'r( _log_probs  zDirichletMultinomial._log_probcCst||Sr-)rexprCr$rBr'r'r(_probszDirichletMultinomial._probcCs|j|j|jdtjfSN.)rrr,rnewaxisr*r'r'r(_mean!szDirichletMultinomial._meanaThe covariance for each batch member is defined as the following: ```none Var(X_j) = n * alpha_j / alpha_0 * (1 - alpha_j / alpha_0) * (n + alpha_0) / (1 + alpha_0) ``` where `concentration = alpha` and `total_concentration = alpha_0 = sum_j alpha_j`. The covariance between elements in a batch is defined as: ```none Cov(X_i, X_j) = -n * alpha_i * alpha_j / alpha_0 ** 2 * (n + alpha_0) / (1 + alpha_0) ``` c CsD||}tt|dtjf|dtjddf |SrG)_variance_scale_termrIrZmatrix_set_diagrmatmulrH _variance)r$r?r'r'r( _covariance%s z DirichletMultinomial._covariancecCs&|}||}||j||Sr-)rJrIr)r$scaler?r'r'r(rL@s zDirichletMultinomial._variancecCs,|jdtjf}td||jd|S)zFHelper to `_covariance` and `_variance` which computes a shared scale..g?)r,rrHrsqrtr)r$Zc0r'r'r(rJEsz)DirichletMultinomial._variance_scale_termcCs*|s|St|}ttj|ddg|S)z3Checks the validity of the concentration parameter.z)Concentration parameter must be positive.message)rZ#embed_check_categorical_event_shaperwith_dependenciesrZassert_positive)r$rrr'r'r(rLsz6DirichletMultinomial._maybe_assert_valid_concentrationcCs8|js|St|}ttj|jt |dddg|S)zBCheck counts for proper shape, values, then return tensor version.rz4counts last-dimension must sum to `self.total_count`rP) rrrrrRrZ assert_equalrrr rEr'r'r(rAXs z/DirichletMultinomial._maybe_assert_valid_sample)FTrr-)__name__ __module__ __qualname____doc__r deprecatedr#propertyrrr,r/r1r2r4r@rZAppendDocstring"_dirichlet_multinomial_sample_noterCrFrIrMrLrJrrA __classcell__r'r'r%r(r2sFo :         N)rVZtensorflow.python.frameworkrrZtensorflow.python.opsrrrrrr Z#tensorflow.python.ops.distributionsr r rZtensorflow.python.utilr Z tensorflow.python.util.tf_exportr __all__rY Distributionrr'r'r'r(s$