mixle.stats.univariate.continuous.tweedie module¶

Tweedie compound Poisson-Gamma distributions for 1 < p < 2.

Data type (float >= 0): the Tweedie exponential-dispersion model with mean mu, dispersion phi, and fixed power p in (1, 2) is the compound Poisson-Gamma law

Y = sum_{i=1}^N G_i, N ~ Poisson(lam), G_i ~ Gamma(shape=a, scale=theta) (iid),

with lam = mu**(2-p) / (phi*(2-p)), a = (2-p)/(p-1), theta = phi*(p-1)*mu**(p-1). There is a point mass P(Y=0) = exp(-lam); for y > 0 the density is the (convergent) series

f(y) = sum_{n>=1} Poisson(n; lam) * Gamma(y; shape=n*a, scale=theta),

evaluated here in log-space via a windowed log-sum-exp over n. E[Y] = mu and Var[Y] = phi * mu**p, so the method of moments (mean for mu, Pearson for phi) is exact; p is a fixed hyperparameter (the profile likelihood over p is left to the caller).

Reference: Jorgensen, The Theory of Dispersion Models (Chapman & Hall, 1997).

class TweedieDistribution(mu, phi, p=1.5, name=None, keys=None)[source]

Bases: SequenceEncodableProbabilityDistribution

Tweedie (compound Poisson-Gamma) distribution on [0, inf) with fixed power p in (1, 2).

Parameters:

mu (float)
phi (float)
p (float)
name (str | None)
keys (str | None)

density(x)[source]

Probability density (or the point mass at 0) at x (see log_density).

Parameters:: x (float)
Return type:: float

log_density(x)[source]

Tweedie log-density: log P(Y=0) = -lam at 0, the series for x > 0, -inf for x < 0.

Parameters:: x (float)
Return type:: float

seq_log_density(x)[source]

Vectorized Tweedie log-density at sequence-encoded non-negative observations x.

Parameters:: x (ndarray)
Return type:: ndarray

classmethod compute_capabilities()[source]: Return compute-backend metadata for Tweedie scoring.

backend_seq_log_density(x, engine)[source]

Engine-neutral vectorized Tweedie log-density for encoded data (see class backend note).

Parameters:

x (Any)
engine (Any)

Return type:

Any

sampler(seed=None)[source]

Return a TweedieSampler for this distribution.

Parameters:: seed (int | None)
Return type:: TweedieSampler

estimator(pseudo_count=None)[source]

Return a TweedieEstimator (method of moments at the fixed power p).

Parameters:: pseudo_count (float | None)
Return type:: TweedieEstimator

dist_to_encoder()[source]

Return the encoder for Tweedie observations.

Return type:: TweedieDataEncoder

class TweedieSampler(dist, seed=None)[source]

Bases: DistributionSampler

Draw iid Tweedie observations exactly as a compound Poisson-Gamma sum.

Parameters:

dist (TweedieDistribution)
seed (int | None)

sample(size=None)[source]

Draw size iid Tweedie samples (a single float if size is None).

Y | N is a sum of N iid Gamma(shape, scale), which is Gamma(N*shape, scale); N = 0 yields an exact zero.

Parameters:: size (int | None)
Return type:: float | ndarray

class TweedieAccumulator(name=None, keys=None)[source]

Bases: SequenceEncodableStatisticAccumulator

Accumulate the weighted count, sum, and sum-of-squares for the moment fit.

Parameters:

name (str | None)
keys (str | None)

update(x, weight, estimate)[source]

Accumulate weighted count, sum, and second moment for one observation.

Parameters:

x (float)
weight (float)
estimate (TweedieDistribution | None)

Return type:

None

initialize(x, weight, rng)[source]

Initialize the sufficient statistics with one weighted observation.

Parameters:

x (float)
weight (float)
rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)[source]

Accumulate weighted count, sum, and second moment from encoded observations.

Parameters:

x (ndarray)
weights (ndarray)
estimate (TweedieDistribution | None)

Return type:

None

seq_initialize(x, weights, rng)[source]

Initialize the sufficient statistics from encoded observations.

Parameters:

x (ndarray)
weights (ndarray)
rng (RandomState | None)

Return type:

None

combine(suff_stat)[source]

Merge serialized moment statistics into this accumulator.

Parameters:: suff_stat (tuple[float, float, float])
Return type:: TweedieAccumulator

value()[source]

Return the total weight, weighted sum, and weighted second moment.

Return type:: tuple[float, float, float]

from_value(x)[source]

Restore the accumulator from serialized moment statistics.

Parameters:: x (tuple[float, float, float])
Return type:: TweedieAccumulator

scale(c)[source]

Scale accumulated moment statistics by a constant.

Parameters:: c (float)
Return type:: TweedieAccumulator

acc_to_encoder()[source]

Return an encoder for non-negative Tweedie observations.

Return type:: TweedieDataEncoder

class TweedieAccumulatorFactory(name=None, keys=None)[source]

Bases: StatisticAccumulatorFactory

Factory for TweedieAccumulator.

Parameters:

name (str | None)
keys (str | None)

make()[source]

Create an empty Tweedie accumulator.

Return type:: TweedieAccumulator

class TweedieEstimator(p=1.5, name=None, keys=None)[source]

Bases: ParameterEstimator

Estimate (mu, phi) at fixed power p by the (exact) method of moments.

Parameters:

p (float)
name (str | None)
keys (str | None)

accumulator_factory()[source]

Return a factory for Tweedie moment accumulators.

Return type:: TweedieAccumulatorFactory

estimate(nobs, suff_stat)[source]

Estimate a Tweedie from the accumulated (count, sum, sum2) via method of moments.

Parameters:

nobs (float | None)
suff_stat (tuple[float, float, float])

Return type:

TweedieDistribution

class TweedieDataEncoder[source]

Bases: DataSequenceEncoder

Encode sequences of iid Tweedie observations (non-negative float data type).

seq_encode(x)[source]

Validate and encode observations as a non-negative float array.

Parameters:: x (Sequence[float])
Return type:: ndarray