mixle.stats.combinator.ignored module

Create, estimate, and sample from an IgnoredDistribution.

Defines the IgnoredDistribution, IgnoredSampler, IgnoredAccumulatorFactory, IgnoredAccumulator, IgnoredEstimator, and the IgnoredDataEncoder classes for use with mixle.

Ignored distribution is simply a distribution that is ignored in estimation and treated as fixed.

class IgnoredDistribution(dist, name=None)[source]

Bases: SequenceEncodableProbabilityDistribution

Distribution wrapper that assigns zero log-density while preserving an estimator interface.

Parameters:

  • dist (SequenceEncodableProbabilityDistribution | None)

  • name (str | None)

compute_capabilities()[source]
compute_declaration()[source]
get_prior()[source]

Delegate to the wrapped distribution’s get_prior (Ignored owns no prior).

Return type:

Any

set_prior(prior)[source]

Delegate to the wrapped distribution’s set_prior; None keeps existing behavior.

Parameters:

prior (Any)

Return type:

None

expected_log_density(x)[source]

Delegate prior-expected log-density to the wrapped distribution.

Parameters:

x (T)

Return type:

float

seq_expected_log_density(x)[source]

Delegate vectorized prior-expected log-density to the wrapped distribution.

Parameters:

x (E)

Return type:

ndarray

density(x)[source]

Evaluate the density of the IgnoredDistribution at x.

Parameters:

x (T) – Type corresponding to attribute ‘dist’.

Returns:

Density of attribute ‘dist’ at x

Return type:

float

log_density(x)[source]

Evaluate the log-density of the IgnoredDistribution at x.

Parameters:

x (T) – Type corresponding to attribute ‘dist’.

Returns:

log-density of attribute ‘dist’ at x.

seq_log_density(x)[source]

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

Parameters:

x (E)

Return type:

ndarray

backend_seq_log_density(x, engine)[source]

Engine-neutral vectorized log-density delegated to the wrapped distribution.

Parameters:

  • x (E)

  • engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)[source]

Return stacked child parameters for homogeneous ignored-wrapper mixtures.

Parameters:
Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)[source]

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

Parameters:
Return type:

Any

classmethod backend_stacked_sufficient_statistics(x, weights, params, engine)[source]

Return empty legacy statistics for each ignored component.

Parameters:
Return type:

Any

sampler(seed=None)[source]

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

IgnoredSampler

estimator(pseudo_count=None)[source]

Return an estimator for fitting this distribution from data.

Parameters:

pseudo_count (float | None)

Return type:

IgnoredEstimator

dist_to_encoder()[source]

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

Return type:

IgnoredDataEncoder

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

Bases: DistributionSampler

Parameters:

  • dist (IgnoredDistribution)

  • seed (int | None)

sample(size=None)[source]

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)

class IgnoredAccumulator(encoder=NullDataEncoder(), name=None)[source]

Bases: SequenceEncodableStatisticAccumulator

Parameters:

  • encoder (DataSequenceEncoder | None)

  • name (str | None)

update(x, weight, estimate)[source]
Parameters:

  • x (T)

  • weight (float)

  • estimate (IgnoredDistribution | None)

Return type:

None

seq_update(x, weights, estimate)[source]
Parameters:

  • x (E)

  • weights (ndarray)

  • estimate (IgnoredDistribution | None)

Return type:

None

seq_update_engine(x, weights, estimate, engine)[source]
Return type:

None

initialize(x, weight, rng)[source]
Parameters:
Return type:

None

seq_initialize(x, weight, rng)[source]
Parameters:
Return type:

None

combine(suff_stat)[source]
Parameters:

suff_stat (Any)

Return type:

IgnoredAccumulator

value()[source]
Return type:

None

from_value(x)[source]
Parameters:

x (Any)

Return type:

IgnoredAccumulator

key_merge(stats_dict)[source]

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)[source]

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()[source]
Return type:

IgnoredDataEncoder

class IgnoredAccumulatorFactory(encoder=NullDataEncoder(), name=None)[source]

Bases: StatisticAccumulatorFactory

Parameters:

  • encoder (DataSequenceEncoder | None)

  • name (str | None)

make()[source]
Return type:

IgnoredAccumulator

class IgnoredEstimator(dist=NullDistribution(), pseudo_count=None, suff_stat=None, keys=None, name=None)[source]

Bases: ParameterEstimator

Parameters:

  • dist (SequenceEncodableProbabilityDistribution | None)

  • pseudo_count (float | None)

  • suff_stat (Any | None)

  • keys (str | None)

  • name (str | None)

accumulator_factory()[source]
get_prior()[source]

Delegate to the wrapped distribution’s get_prior (Ignored estimates nothing of its own).

Return type:

Any

set_prior(prior)[source]

Delegate to the wrapped distribution’s set_prior; None keeps existing behavior.

Parameters:

prior (Any)

Return type:

None

estimate(nobs, suff_stat)[source]
Parameters:
Return type:

IgnoredDistribution

class IgnoredDataEncoder(encoder=NullDataEncoder())[source]

Bases: DataSequenceEncoder

Parameters:

encoder (DataSequenceEncoder | None)

seq_encode(x)[source]

Encode the iid observation sequence x for vectorized evaluation.

Parameters:

x (Sequence[T])

Return type:

Any