mixle.stats.univariate.continuous.beta module

Beta distributions over values in the unit interval.

Reference: Johnson, Kotz & Balakrishnan, Continuous Univariate Distributions (2nd ed., Wiley, 1994/95).

class BetaFisherView(dist)

Bases: FixedFisherView

Fisher view for Beta sufficient statistics.

Parameters:

dist (Any)

class BetaDistribution(a, b, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Beta distribution with positive shape parameters a and b.

Parameters:

• a (float)

• b (float)

• name (str | None)

• keys (str | None)

classmethod compute_capabilities()

Describe backend support for generated Beta kernels.

classmethod compute_declaration()

Return the structured compute declaration for Beta distributions.

static exp_family_sufficient_statistics(x, engine)

Return Beta sufficient statistics for generated scoring.

Scoring needs only log_x and log1m_x (the two natural-parameter partners). The encoder emits the full (log_x, log1m_x, x, x**2) tuple for the M-step, while the symbolic generator supplies just the two scoring symbols from backend_log_density_from_params; indexing the leading two works for both arities.

Parameters:

• x (tuple[Any, Any, Any, Any])

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_legacy_sufficient_statistics(x, params, engine)

Return per-row Beta sufficient statistics in accumulator order.

Parameters:

• x (tuple[Any, Any, Any, Any])

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_natural_parameters(params, engine)

Return Beta natural parameters for generated scoring.

Parameters:

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_log_partition(params, engine)

Return Beta log partition for generated scoring.

Parameters:

• params (dict[str, Any])

• engine (Any)

Return type:

Any

get_parameters()

Return the (a, b) shape pair.

Lets a BetaDistribution serve as a conjugate prior (on a Bernoulli/Geometric/Binomial success probability) under the unified Bayesian estimation protocol.

Return type:

tuple[float, float]

density(x)

Return the probability density or mass at a single observation.

Parameters:

x (float)

Return type:

float

log_density(x)

Return the log-density or log-mass at a single observation.

Parameters:

x (float)

Return type:

float

seq_log_density(x)

Return vectorized log-density values for sequence-encoded observations.

Parameters:

x (tuple[ndarray, ndarray, ndarray, ndarray])

Return type:

ndarray

static backend_log_density_from_params(log_x, log1m_x, a, b, engine)

Engine-neutral Beta log-density from encoded logs and parameters.

Parameters:

• log_x (Any)

• log1m_x (Any)

• a (Any)

• b (Any)

• engine (Any)

Return type:

Any

backend_seq_log_density(x, engine)

Engine-neutral vectorized log-density for encoded data.

Parameters:

• x (tuple[Any, Any, Any, Any])

• engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)

Return stacked Beta parameters for a homogeneous mixture kernel.

Parameters:

• dists (Sequence[BetaDistribution])

• engine (Any)

Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)

Return an (n, k) matrix of Beta log densities.

Parameters:

• x (tuple[Any, Any, Any, Any])

• params (dict[str, Any])

• engine (Any)

Return type:

Any

cdf(x)

Cumulative distribution function P(X <= x) (exact). The continuous ‘index of’ a value.

Parameters:

x (float)

Return type:

float

quantile(q)

Inverse CDF F^{-1}(q): the value at cumulative-probability index q (continuous unranking).

Parameters:

q (float)

Return type:

float

to_fisher(**kwargs)

Return this distribution’s own Fisher view.

mean()

Mean E[X] of the distribution.

Return type:

float

variance()

Variance Var[X] of the distribution.

Return type:

float

entropy()

Differential entropy ln B(a,b) - (a-1)psi(a) - (b-1)psi(b) + (a+b-2)psi(a+b).

Return type:

float

mode()

Mode (a-1)/(a+b-2) for a,b>1; boundary otherwise.

Return type:

float

sampler(seed=None)

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

BetaSampler

estimator(pseudo_count=None)

Return an estimator for fitting this distribution from data.

Parameters:

pseudo_count (float | None)

Return type:

BetaEstimator

dist_to_encoder()

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

Return type:

BetaDataEncoder

class BetaSampler(dist, seed=None)

Bases: DistributionSampler

Draw iid beta observations.

Parameters:

• dist (BetaDistribution)

• seed (int | None)

sample(size=None)

Draw one sample or an array of iid samples.

Parameters:

size (int | None)

Return type:

float | ndarray

class BetaAccumulator(name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate sufficient statistics for beta estimation.

Parameters:

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Accumulate weighted statistics for one observation in (0, 1).

Parameters:

• x (float)

• weight (float)

• estimate (BetaDistribution | None)

Return type:

None

initialize(x, weight, rng)

Initialize statistics from one observation.

Parameters:

• x (float)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)

Accumulate weighted statistics from encoded observations.

Parameters:

• x (tuple[ndarray, ndarray, ndarray, ndarray])

• weights (ndarray)

• estimate (BetaDistribution | None)

Return type:

None

seq_initialize(x, weights, rng)

Initialize statistics from encoded observations.

Parameters:

• x (tuple[ndarray, ndarray, ndarray, ndarray])

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Merge another Beta sufficient-statistic tuple.

Parameters:

suff_stat (tuple[float, float, float, float, float])

Return type:

BetaAccumulator

value()

Return the accumulated Beta sufficient statistics.

Return type:

tuple[float, float, float, float, float]

from_value(x)

Replace accumulator contents from a sufficient-statistic tuple.

Parameters:

x (tuple[float, float, float, float, float])

Return type:

BetaAccumulator

key_merge(stats_dict)

Merge keyed statistics into stats_dict when keys are configured.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Replace this accumulator from keyed statistics when available.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return the encoder used by this accumulator.

Return type:

BetaDataEncoder

class BetaAccumulatorFactory(name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for BetaAccumulator.

Parameters:

• name (str | None)

• keys (str | None)

make()

Create a fresh Beta accumulator.

Return type:

BetaAccumulator

class BetaEstimator(pseudo_count=None, suff_stat=None, delta=1.0e-8, name=None, keys=None)

Bases: ParameterEstimator

Estimate beta shape parameters from weighted log-moment statistics.

Parameters:

• pseudo_count (float | None)

• suff_stat (Sequence[float] | None)

• delta (float)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return an accumulator factory for Beta sufficient statistics.

Return type:

BetaAccumulatorFactory

estimate(nobs, suff_stat)

Estimate Beta shape parameters from weighted sufficient statistics.

Parameters:

• nobs (float | None)

• suff_stat (tuple[float, float, float, float, float])

Return type:

BetaDistribution

class BetaDataEncoder

Bases: DataSequenceEncoder

Encode beta observations with log x and log(1-x) columns.

seq_encode(x)

Encode observations as log and moment arrays for vectorized updates.

Parameters:

x (Sequence[float])

Return type:

tuple[ndarray, ndarray, ndarray, ndarray]