Skip to content

aether_quant.moe

Mixture-of-experts gating.

Mixture-of-experts gating.

ExpertGateWeight dataclass

One expert's weight in the gated blend, with its raw score.

expert instance-attribute

expert: str

gating_eligible instance-attribute

gating_eligible: bool

magnitude class-attribute instance-attribute

magnitude: float | None = None

performance_score instance-attribute

performance_score: float

probability_up instance-attribute

probability_up: float | None

quality_multiplier instance-attribute

quality_multiplier: float

quality_status instance-attribute

quality_status: str

raw_score instance-attribute

raw_score: float

reason instance-attribute

reason: str

regime_alignment instance-attribute

regime_alignment: float

volatility class-attribute instance-attribute

volatility: float | None = None

weight instance-attribute

weight: float

to_dict

to_dict() -> dict[str, Any]

GatingDecision dataclass

The gated probability of an up move, the baseline and expert inputs, and each expert's weight.

active_experts instance-attribute

active_experts: list[str]

baseline_probability_up instance-attribute

baseline_probability_up: float | None

decision_source instance-attribute

decision_source: str

disabled_experts instance-attribute

disabled_experts: list[str]

expert_probability_up instance-attribute

expert_probability_up: float | None

final_magnitude class-attribute instance-attribute

final_magnitude: float | None = None

final_probability_up instance-attribute

final_probability_up: float

final_volatility class-attribute instance-attribute

final_volatility: float | None = None

sequence_blended class-attribute instance-attribute

sequence_blended: bool = False

weights instance-attribute

weights: list[ExpertGateWeight]

to_dict

to_dict() -> dict[str, Any]

build_gating_decision

build_gating_decision(regime: dict[str, Any], expert_training_metrics: dict[str, Any], expert_probabilities: dict[str, float | None], baseline_probability_up: float | None = None, baseline_weight: float = 0.25, gating_model: dict[str, Any] | None = None, gating_feature_schema: dict[str, Any] | None = None, expert_magnitudes: dict[str, float | None] | None = None, expert_volatilities: dict[str, float | None] | None = None, baseline_magnitude: float | None = None, baseline_volatility: float | None = None, sequence_prediction: dict[str, Any] | None = None, sequence_weight: float = 0.0, excluded_experts: tuple[str, ...] | frozenset[str] = ()) -> GatingDecision

excluded_experts (V6.4.0, phase_v2.gating_network.disabled_experts, default none): experts treated as having no probability, so the others renormalise - the expert-ablation switch (lead L8).

build_gating_model_features

build_gating_model_features(regime: dict[str, Any], baseline_probability_up: float | None, weights: list[ExpertGateWeight]) -> list[float]

Pure feature-vector builder for the optional learned gating model - same fixed order as GATING_MODEL_FEATURE_KEYS. weights must contain exactly one ExpertGateWeight per EXPERT_NAMES entry, which build_gating_decision() always guarantees.