mixle.stats.univariate.discrete.bernoulli module

Bernoulli distributions over binary outcomes.

Data type: bool or values in {0, 1}. The distribution has success probability p and log-density log(p) for True/1 and log(1-p) for False/0.

Reference: Johnson, Kemp & Kotz, Univariate Discrete Distributions (3rd ed., Wiley, 2005).

class BernoulliDistribution(p, name=None, keys=None, prior=None)

Bases: SequenceEncodableProbabilityDistribution

Bernoulli distribution over {False, True} with success probability p.

Parameters:

• p (float)

• name (str | None)

• keys (str | None)

• prior (SequenceEncodableProbabilityDistribution | None)

classmethod compute_capabilities()

Describe backend support for generated Bernoulli kernels.

classmethod compute_declaration()

Return the structured compute declaration for Bernoulli distributions.

static exp_family_sufficient_statistics(x, engine)

Return Bernoulli sufficient statistics for generated scoring.

Parameters:

• x (Any)

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_legacy_sufficient_statistics(x, params, engine)

Return per-row Bernoulli sufficient statistics in accumulator order.

Parameters:

• x (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_natural_parameters(params, engine)

Return Bernoulli natural parameters for generated scoring.

Parameters:

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, …]

static exp_family_log_partition(params, engine)

Return Bernoulli log partition for generated scoring.

Parameters:

• params (dict[str, Any])

• engine (Any)

Return type:

Any

set_prior(prior)

Attach a Beta parameter prior and precompute conjugate-prior expectations.

With a Beta(a, b) prior on the success probability p this caches the digamma terms so that expected_log_density evaluates the variational Bayes expectation E_q[log p(x | p)] via E[log p] = digamma(a) - digamma(a+b) and E[log(1-p)] = digamma(b) - digamma(a+b). Any other prior (including None) leaves the distribution a plain point model.

Parameters:

prior (SequenceEncodableProbabilityDistribution | None)

Return type:

None

expected_log_density(x)

Variational expectation E_q[log p(x | p)] under the Beta prior.

Falls back to the plug-in log_density(x) when no conjugate prior is attached.

Parameters:

x (bool | int)

Return type:

float

seq_expected_log_density(x)

Vectorized expected_log_density over sequence-encoded observations.

Parameters:

x (ndarray)

Return type:

ndarray

density(x)

Return the probability density or mass at a single observation.

Parameters:

x (bool | int)

Return type:

float

log_density(x)

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

Parameters:

x (bool | int)

Return type:

float

seq_log_density(x)

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

Parameters:

x (ndarray)

Return type:

ndarray

static backend_log_density_from_params(x, p, engine)

Engine-neutral Bernoulli log-mass from explicit parameters.

Parameters:

• x (Any)

• p (Any)

• engine (Any)

Return type:

Any

backend_seq_log_density(x, engine)

Engine-neutral vectorized log-density for encoded data.

Parameters:

• x (Any)

• engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)

Return stacked Bernoulli parameters for a homogeneous mixture kernel.

Parameters:

• dists (Sequence[BernoulliDistribution])

• engine (Any)

Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)

Return an (n, k) matrix of Bernoulli log masses.

Parameters:

• x (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

Any

classmethod backend_stacked_sufficient_statistics(x, weights, params, engine)

Return stacked Bernoulli sufficient statistics using engine-resident arrays.

Parameters:

• x (Any)

• weights (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

tuple[Any, Any]

support_size()

The two outcomes {0, 1}.

Return type:

int

to_fisher(**kwargs)

Return the Bernoulli’s count-family Fisher view.

mean()

Mean E[X] of the distribution.

Return type:

float

variance()

Variance Var[X] of the distribution.

Return type:

float

cdf(x)

Cumulative distribution function P(X <= x) over {0, 1}.

Parameters:

x (float)

Return type:

float

skewness()

Skewness (1-2p)/sqrt(p(1-p)).

Return type:

float

kurtosis()

Excess kurtosis (1-6p(1-p))/(p(1-p)).

Return type:

float

quantile(q)

Inverse CDF F^{-1}(q) over {0, 1}.

Parameters:

q (float)

Return type:

float

entropy()

Shannon entropy -p log p - (1-p) log(1-p) (nats).

Return type:

float

mode()

Mode (0 if p<1/2 else 1).

Return type:

float

sampler(seed=None)

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

BernoulliSampler

estimator(pseudo_count=None)

Return an estimator for fitting this distribution from data.

Parameters:

pseudo_count (float | None)

Return type:

BernoulliEstimator

dist_to_encoder()

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

Return type:

BernoulliDataEncoder

enumerator()

Return an enumerator over the distribution support when available.

Return type:

BernoulliEnumerator

class BernoulliEnumerator(dist)

Bases: DistributionEnumerator

Enumerate False/True in descending probability order.

Parameters:

dist (BernoulliDistribution)

class BernoulliSampler(dist, seed=None)

Bases: DistributionSampler

Draw iid Bernoulli observations.

Parameters:

• dist (BernoulliDistribution)

• seed (int | None)

sample(size=None)

Draw one sample or a list of iid samples.

Parameters:

size (int | None)

Return type:

bool | Sequence[bool]

class BernoulliAccumulator(name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate weighted success and observation counts.

Parameters:

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Accumulate weighted success and count statistics for one observation.

Parameters:

• x (bool | int)

• weight (float)

• estimate (BernoulliDistribution | None)

Return type:

None

initialize(x, weight, rng)

Initialize statistics from one observation.

Parameters:

• x (bool | int)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)

Accumulate weighted statistics from encoded observations.

Parameters:

• x (ndarray)

• weights (ndarray)

• estimate (BernoulliDistribution | None)

Return type:

None

seq_initialize(x, weights, rng)

Initialize statistics from encoded observations.

Parameters:

• x (ndarray)

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Merge another Bernoulli sufficient-statistic tuple.

Parameters:

suff_stat (tuple[float, float])

Return type:

BernoulliAccumulator

value()

Return the accumulated count and success total.

Return type:

tuple[float, float]

from_value(x)

Replace accumulator contents from a sufficient-statistic tuple.

Parameters:

x (tuple[float, float])

Return type:

BernoulliAccumulator

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:

BernoulliDataEncoder

class BernoulliAccumulatorFactory(name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for BernoulliAccumulator.

Parameters:

• name (str | None)

• keys (str | None)

make()

Create a fresh Bernoulli accumulator.

Return type:

BernoulliAccumulator

class BernoulliEstimator(pseudo_count=None, suff_stat=None, name=None, keys=None, prior=None)

Bases: ParameterEstimator

Estimate a Bernoulli distribution from weighted success counts.

Parameters:

• pseudo_count (float | None)

• suff_stat (float | None)

• name (str | None)

• keys (str | None)

• prior (SequenceEncodableProbabilityDistribution | None)

accumulator_factory()

Return an accumulator factory for Bernoulli sufficient statistics.

Return type:

BernoulliAccumulatorFactory

model_log_density(model)

Log-density of the model’s success probability under the Beta prior (ELBO global term).

Parameters:

model (BernoulliDistribution)

Return type:

float

estimate(nobs, suff_stat)

Estimate the Bernoulli success probability from weighted counts.

Parameters:

• nobs (float | None)

• suff_stat (tuple[float, float])

Return type:

BernoulliDistribution

class BernoulliDataEncoder

Bases: DataSequenceEncoder

Encode Bernoulli observations as a boolean numpy array.

seq_encode(x)

Encode Bernoulli observations as a boolean array.

Parameters:

x (Sequence[bool | int])

Return type:

ndarray