Struct AttentionMask 

pub struct AttentionMask {
    pub num_heads: usize,
    pub num_layers: usize,
    pub mask: Vec<Vec<bool>>,
    pub layer_sparsity: Vec<f32>,
    pub overall_sparsity: f32,
}

A mask indicating which attention heads to compute

Fields

num_heads: usize

Number of heads

num_layers: usize

Number of layers

mask: Vec<Vec<bool>>

Mask values: true = compute, false = skip Indexed as [layer][head]

layer_sparsity: Vec<f32>

Per-layer sparsity (fraction of heads skipped)

overall_sparsity: f32

Overall sparsity

Implementations

impl AttentionMask

pub fn all_active(num_heads: usize, num_layers: usize) -> Self

Create a mask with all heads active

pub fn random(num_heads: usize, num_layers: usize, sparsity: f32) -> Self

Create a mask with uniform random sparsity

pub fn from_mask(mask: Vec<Vec<bool>>) -> Self

Create from raw mask data

pub fn is_active(&self, layer: usize, head: usize) -> bool

Check if a head is active

pub fn set_active(&mut self, layer: usize, head: usize, active: bool)

Set head activity

pub fn active_heads(&self, layer: usize) -> Vec<usize>

Get active head indices for a layer

pub fn inactive_heads(&self, layer: usize) -> Vec<usize>

Get inactive head indices for a layer

pub fn active_count(&self, layer: usize) -> usize

Number of active heads in a layer

pub fn merge_and(&self, other: &AttentionMask) -> Result<Self>

Merge with another mask (AND operation - both must be active)

pub fn merge_or(&self, other: &AttentionMask) -> Result<Self>

Merge with another mask (OR operation - either can be active)

pub fn ensure_minimum(&mut self, min_active: usize)

Ensure minimum active heads per layer

pub fn to_bytes(&self) -> Vec<u8>

Convert to compact byte representation

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserialize from bytes

Trait Implementations

impl Clone for AttentionMask

fn clone(&self) -> AttentionMask

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AttentionMask

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

Formats the value using the given formatter.

impl Default for AttentionMask

fn default() -> Self

Creates an empty attention mask with no heads or layers.

Use AttentionMask::all_active(num_heads, num_layers) to create a mask with specific dimensions where all heads are active.

impl<'de> Deserialize<'de> for AttentionMask

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AttentionMask

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

where __S: Serializer,

Serialize this value into the given Serde serializer.