mixle.stats.combinator.ignored module

Distribution wrapper that keeps a child’s parameters fixed during estimation.

IgnoredDistribution delegates the child’s likelihood, sampling, and encoding unchanged; only its accumulator is a no-op, so the child contributes to model scores but is not re-estimated.

class IgnoredDistribution(dist, name=None)

Bases: SequenceEncodableProbabilityDistribution

Fixed-parameter wrapper that delegates the wrapped distribution’s likelihood exactly.

Parameters:

• dist (SequenceEncodableProbabilityDistribution | None)

• name (str | None)

compute_capabilities()

Return the compute capabilities delegated from the wrapped distribution.

compute_declaration()

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

get_prior()

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

Return type:

Any

set_prior(prior)

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

Parameters:

prior (Any)

Return type:

None

expected_log_density(x)

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

Parameters:

x (T)

Return type:

float

seq_expected_log_density(x)

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

Parameters:

x (E)

Return type:

ndarray

density(x)

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)

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)

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

Parameters:

x (E)

Return type:

ndarray

backend_seq_log_density(x, engine)

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

Parameters:

• x (E)

• engine (Any)

Return type:

Any

classmethod backend_stacked_params(dists, engine)

Return stacked child parameters for homogeneous ignored-wrapper mixtures.

Parameters:

• dists (Sequence[IgnoredDistribution])

• engine (Any)

Return type:

dict[str, Any]

classmethod backend_stacked_log_density(x, params, engine)

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

Parameters:

• x (E)

• params (dict[str, Any])

• engine (Any)

Return type:

Any

classmethod backend_stacked_sufficient_statistics(x, weights, params, engine)

Return empty legacy statistics for each ignored component.

Parameters:

• x (E)

• weights (Any)

• params (dict[str, Any])

• engine (Any)

Return type:

Any

sampler(seed=None)

Return a sampler for drawing observations from this distribution.

Parameters:

seed (int | None)

Return type:

IgnoredSampler

estimator(pseudo_count=None)

Return an estimator for fitting this distribution from data.

Parameters:

pseudo_count (float | None)

Return type:

IgnoredEstimator

dist_to_encoder()

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

Return type:

IgnoredDataEncoder

class IgnoredSampler(dist, seed=None)

Bases: DistributionSampler

Sampler that delegates exactly to the fixed wrapped distribution.

Parameters:

• dist (IgnoredDistribution)

• seed (int | None)

sample(size=None, *, batched=True)

Draw from the wrapped sampler.

Parameters:

• size (int | None)

• batched (bool)

class IgnoredAccumulator(encoder=NullDataEncoder(), name=None)

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)

Ignore a single weighted observation.

Parameters:

• x (T)

• weight (float)

• estimate (IgnoredDistribution | None)

Return type:

None

seq_update(x, weights, estimate)

Ignore a batch of encoded observations.

Parameters:

• x (E)

• weights (ndarray)

• estimate (IgnoredDistribution | None)

Return type:

None

seq_update_engine(x, weights, estimate, engine)

Ignore a batch of engine-resident observations.

Return type:

None

initialize(x, weight, rng)

Ignore a single initialization observation.

Parameters:

• x (T)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_initialize(x, weight, rng)

Ignore a batch of initialization observations.

Parameters:

• x (E)

• weight (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Return this accumulator because ignored statistics have no state.

Parameters:

suff_stat (Any)

Return type:

IgnoredAccumulator

value()

Return None because ignored statistics are intentionally empty.

Return type:

None

from_value(x)

Return this accumulator because there is no state to restore.

Parameters:

x (Any)

Return type:

IgnoredAccumulator

key_merge(stats_dict)

Perform no keyed merge because ignored statistics have no state.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Perform no keyed replacement because ignored statistics have no state.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return the encoder associated with the wrapped distribution.

Return type:

IgnoredDataEncoder

class IgnoredAccumulatorFactory(encoder=NullDataEncoder(), name=None)

Bases: StatisticAccumulatorFactory

Create no-op accumulators for ignored distributions.

Parameters:

• encoder (DataSequenceEncoder | None)

• name (str | None)

make()

Create an ignored-distribution accumulator.

Return type:

IgnoredAccumulator

class IgnoredEstimator(dist=None, pseudo_count=None, suff_stat=None, keys=None, name=None)

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()

Return a factory that creates no-op ignored accumulators.

get_prior()

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

Return type:

Any

set_prior(prior)

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

Parameters:

prior (Any)

Return type:

None

estimate(nobs, suff_stat)

Return the wrapped distribution unchanged inside IgnoredDistribution.

Parameters:

• nobs (float | None)

• suff_stat (Any)

Return type:

IgnoredDistribution

class IgnoredDataEncoder(encoder=NullDataEncoder())

Bases: DataSequenceEncoder

Encoder that delegates to the wrapped distribution’s encoder.

Parameters:

encoder (DataSequenceEncoder | None)

seq_encode(x)

Encode observations with the wrapped distribution’s encoder.

Parameters:

x (Sequence[T])

Return type:

Any

row_count(x)

Return the wrapped encoder’s row count for a payload this wrapper produced.

seq_encode returns the child payload verbatim, so the child encoder is the only authority on that layout. Without this delegation the abstract default had to guess the leading count from the payload’s shape, and for every child whose encoding is not a single aligned block it guessed nothing and raised NotImplementedError naming this class – which killed the frozen/identifier column path outright (a pandas datetime column, an identifier string column, any pd.NA-bearing column: each encodes to a categorical (indices, levels) pair whose two members have different lengths whenever the level count differs from the row count). The crash surfaced from seq_encode’s row-conservation check, so it took down optimize/Model.fit for the exact tables the frozen-column stand-in exists to support.

Parameters:

x (Any)

Return type:

int