Enum InterventionAction 

pub enum InterventionAction {
    Zero {
        dtype: InterventionDtype,
    },
    Scale {
        dtype: InterventionDtype,
        factor: f32,
    },
    Mask {
        dtype: InterventionDtype,
        shape: Vec<u64>,
        keep: Vec<bool>,
    },
    Replace {
        tensor: InterventionTensor,
    },
    Add {
        tensor: InterventionTensor,
    },
    MaskLogits {
        dtype: InterventionDtype,
        token_ids: Vec<u32>,
    },
    ExcludeExperts {
        expert_ids: Vec<u32>,
    },
    ZeroExpertContribution {
        expert_ids: Vec<u32>,
    },
    BiasRoutingScores {
        stage: RoutingScoreStage,
        expert_ids: Vec<u32>,
        biases: Vec<f32>,
    },
    ForceExperts {
        shape: [u64; 2],
        expert_ids: Vec<u32>,
    },
}

One typed mutation. No variant contains native handles or executable code.

Variants

Zero

Zero selected elements; retains dtype and shape.

Fields

dtype: InterventionDtype

Required runtime storage dtype.

Scale

Native multiplication; the finite scalar must be representable in the dtype.

Fields

dtype: InterventionDtype

Required runtime storage dtype.

factor: f32

Finite scalar, with native dtype rounding.

Mask

False entries become zero; shape must exactly equal the selected region.

Fields

dtype: InterventionDtype

Required runtime storage dtype.

shape: Vec<u64>

Complete selected extents.

keep: Vec<bool>

Row-major keep bits.

Replace

Whole-value replacement or patching according to the explicit axis slices.

Fields

tensor: InterventionTensor

Complete exact-dtype selected values.

Add

Elementwise addition; supports typed logit bias without a second sampler.

Fields

tensor: InterventionTensor

Complete exact-dtype selected values.

MaskLogits

Negative-infinity mask at final logits; selection must retain full vocabulary.

Fields

dtype: InterventionDtype

Required runtime storage dtype.

token_ids: Vec<u32>

Unique canonical vocabulary IDs.

ExcludeExperts

Eligibility exclusion before the architecture’s existing selection algorithm. Gathered scores retain ordinary normalization and scaling semantics.

Fields

expert_ids: Vec<u32>

Unique global routed-expert IDs.

ZeroExpertContribution

Suppress selected contributions without reselection or renormalization. Remaining coefficients retain their original magnitude. Expert computation is not promised to be avoided. Shared experts remain unchanged.

Fields

expert_ids: Vec<u32>

Unique global routed-expert IDs.

BiasRoutingScores

Per-expert bias replicated explicitly over the selected token rows.

Fields

stage: RoutingScoreStage

Precise scoring boundary.

expert_ids: Vec<u32>

Unique global routed-expert IDs.

biases: Vec<f32>

One finite additive bias per listed expert.

ForceExperts

Replace selected IDs before dispatch. Scores/weights are gathered from the architecture’s router, preserving its normalization, scaling and learned multipliers. There is no caller coefficient override.

Fields

shape: [u64; 2]

Exact [selected_token_rows, top_k] extents.

expert_ids: Vec<u32>

Complete row-major global routed-expert IDs.

Implementations

impl InterventionAction

pub fn validate_activation_region( &self, dtype: InterventionDtype, shape: &[u64], ) -> Result<(), CaptureError>

Revalidates complete host parameters against an exact native selected region.

pub fn kind(&self) -> InterventionKind

Exact operation category.

pub fn dtype(&self) -> Option<InterventionDtype>

Exact activation dtype, absent for architecture-owned routing arithmetic.

Trait Implementations

impl Clone for InterventionAction

fn clone(&self) -> InterventionAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InterventionAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InterventionAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for InterventionAction

fn eq(&self, other: &InterventionAction) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for InterventionAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InterventionAction