mixle.stats.combinator.ignored module

Distribution wrapper that keeps a child model fixed during estimation.

IgnoredDistribution preserves the child distribution’s sampling and encoding hooks where appropriate while contributing no fitted sufficient statistics of its own.

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]

Return the compute capabilities delegated from the wrapped distribution.

compute_declaration()[source]

Return a declaration that marks this wrapper as carrying no estimable statistics.

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

Sampler that delegates to the wrapped distribution or emits None for null children.

Parameters:

  • dist (IgnoredDistribution)

  • seed (int | None)

sample(size=None)[source]

Draw from the wrapped sampler, preserving null-distribution None samples.

Parameters:

size (int | None)

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

Bases: SequenceEncodableStatisticAccumulator

No-op accumulator used when a wrapped distribution should not update during estimation.

Parameters:

  • encoder (DataSequenceEncoder | None)

  • name (str | None)

update(x, weight, estimate)[source]

Ignore a single weighted observation.

Parameters:

  • x (T)

  • weight (float)

  • estimate (IgnoredDistribution | None)

Return type:

None

seq_update(x, weights, estimate)[source]

Ignore a batch of encoded observations.

Parameters:

  • x (E)

  • weights (ndarray)

  • estimate (IgnoredDistribution | None)

Return type:

None

seq_update_engine(x, weights, estimate, engine)[source]

Ignore a batch of engine-resident observations.

Return type:

None

initialize(x, weight, rng)[source]

Ignore a single initialization observation.

Parameters:
Return type:

None

seq_initialize(x, weight, rng)[source]

Ignore a batch of initialization observations.

Parameters:
Return type:

None

combine(suff_stat)[source]

Return this accumulator because ignored statistics have no state.

Parameters:

suff_stat (Any)

Return type:

IgnoredAccumulator

value()[source]

Return None because ignored statistics are intentionally empty.

Return type:

None

from_value(x)[source]

Return this accumulator because there is no state to restore.

Parameters:

x (Any)

Return type:

IgnoredAccumulator

key_merge(stats_dict)[source]

Perform no keyed merge because ignored statistics have no state.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)[source]

Perform no keyed replacement because ignored statistics have no state.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()[source]

Return the encoder associated with the wrapped distribution.

Return type:

IgnoredDataEncoder

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

Bases: StatisticAccumulatorFactory

Create no-op accumulators for ignored distributions.

Parameters:

  • encoder (DataSequenceEncoder | None)

  • name (str | None)

make()[source]

Create an ignored-distribution accumulator.

Return type:

IgnoredAccumulator

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

Bases: ParameterEstimator

Estimator that returns the wrapped distribution unchanged inside an ignored wrapper.

Parameters:

  • dist (SequenceEncodableProbabilityDistribution | None)

  • pseudo_count (float | None)

  • suff_stat (Any | None)

  • keys (str | None)

  • name (str | None)

accumulator_factory()[source]

Return a factory that creates no-op ignored accumulators.

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]

Return the wrapped distribution unchanged inside IgnoredDistribution.

Parameters:
Return type:

IgnoredDistribution

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

Bases: DataSequenceEncoder

Encoder that delegates to the wrapped distribution’s encoder.

Parameters:

encoder (DataSequenceEncoder | None)

seq_encode(x)[source]

Encode observations with the wrapped distribution’s encoder.

Parameters:

x (Sequence[T])

Return type:

Any