mixle.stats.multivariate.dirichlet_multinomial module

Dirichlet-multinomial (Polya) distribution – an overdispersed multinomial.

The multivariate analogue of the beta-binomial: a multinomial whose category probabilities are Dirichlet(alpha) distributed and integrated out. For a count vector x over K categories summing to n,

P(x; alpha) = n!/prod_k x_k! * B(alpha + x) / B(alpha), B(a) = prod_k Gamma(a_k) / Gamma(sum a),

which adds overdispersion (and category correlation) over a plain multinomial. The number of trials n is a fixed, known parameter; alpha is fit by Minka’s maximum-likelihood fixed point, run from a cumulative-count sufficient statistic so it converges inside a single estimate call.

class DirichletMultinomialDistribution(alpha, n, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Dirichlet-multinomial over K-category count vectors summing to n (concentration alpha).

Parameters:

• alpha (ndarray)

• n (int)

• name (str | None)

• keys (str | None)

density(x)

Return the probability mass at a single count vector x.

Parameters:

x (ndarray)

Return type:

float

log_density(x)

Return the log-mass at x (-inf if any count is negative or the total is not n).

Parameters:

x (ndarray)

Return type:

float

seq_log_density(x)

Vectorized log-mass for a stack of count vectors, shape (N, K).

Parameters:

x (ndarray)

Return type:

ndarray

sampler(seed=None)

Return a sampler for drawing count vectors from this distribution.

Parameters:

seed (int | None)

Return type:

DirichletMultinomialSampler

estimator(pseudo_count=None)

Return a Minka fixed-point MLE estimator for alpha at the fixed number of trials n.

Parameters:

pseudo_count (float | None)

Return type:

DirichletMultinomialEstimator

dist_to_encoder()

Return the data encoder used by this distribution for vectorized methods.

Return type:

DirichletMultinomialDataEncoder

class DirichletMultinomialSampler(dist, seed=None)

Bases: DistributionSampler

Draw counts as p ~ Dirichlet(alpha) then x ~ Multinomial(n, p).

Parameters:

• dist (DirichletMultinomialDistribution)

• seed (int | None)

sample(size=None)

Draw observations.

Combinator samplers (mixture/sequence/…) accept batched. With batched=True (the default) each child stream is drawn in one vectorized call instead of a per-draw Python loop – far faster. Because every child sampler owns an independent RandomState, batching consumes each stream in the same order as the loop, so the draws are identical to the legacy path. batched=False forces that legacy per-draw loop as a guaranteed- stable reference. Leaf samplers are already vectorized and ignore the flag.

Parameters:

size (int | None)

Return type:

ndarray

class DirichletMultinomialAccumulator(dim, n, name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate cumulative counts c[k, j] = sum_i w_i 1{x_ik > j} (the Minka digamma-recurrence stat).

Parameters:

• dim (int)

• n (int)

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Parameters:

• x (ndarray)

• weight (float)

• estimate (DirichletMultinomialDistribution | None)

Return type:

None

initialize(x, weight, rng)

Parameters:

• x (ndarray)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)

Parameters:

• x (ndarray)

• weights (ndarray)

• estimate (Any)

Return type:

None

seq_initialize(x, weights, rng)

Parameters:

• x (ndarray)

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Parameters:

suff_stat (tuple[ndarray, float])

Return type:

DirichletMultinomialAccumulator

value()

Return type:

tuple[ndarray, float]

from_value(x)

Parameters:

x (tuple[ndarray, float])

Return type:

DirichletMultinomialAccumulator

key_merge(stats_dict)

Pool this accumulator’s statistics into stats_dict under its merge key.

The structural default implements the common single-key pattern: store the accumulator under self.keys the first time the key is seen, else combine into the one already there. Accumulators with several named keys (e.g. an HMM’s init/trans/state keys) or a non-accumulator stats payload override this. A keys of None (the default) is a no-op.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Replace this accumulator’s statistics from the pooled stats_dict entry (see key_merge).

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return type:

DirichletMultinomialDataEncoder

class DirichletMultinomialAccumulatorFactory(dim, n, name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for DirichletMultinomialAccumulator.

Parameters:

• dim (int)

• n (int)

• name (str | None)

• keys (str | None)

make()

Return type:

DirichletMultinomialAccumulator

class DirichletMultinomialEstimator(dim, n, max_iter=500, tol=1.0e-9, name=None, keys=None)

Bases: ParameterEstimator

Minka fixed-point maximum-likelihood estimator for the Dirichlet-multinomial concentration.

Parameters:

• dim (int)

• n (int)

• max_iter (int)

• tol (float)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return type:

DirichletMultinomialAccumulatorFactory

estimate(nobs, suff_stat)

Parameters:

• nobs (float | None)

• suff_stat (tuple[ndarray, float])

Return type:

DirichletMultinomialDistribution

class DirichletMultinomialDataEncoder

Bases: DataSequenceEncoder

Encode a sequence of K-category count vectors as an (N, K) array.

seq_encode(x)

Encode the iid observation sequence x for vectorized evaluation.

Parameters:

x (Sequence[ndarray])

Return type:

ndarray