Struct SensorEncoderConfig 

pub struct SensorEncoderConfig {
    pub time_steps: usize,
    pub num_channels: usize,
    pub patch_h: usize,
    pub patch_w: usize,
    pub d_model: usize,
    pub depth: usize,
    pub num_heads: usize,
    pub mlp_dim: usize,
    pub dropout: f64,
    pub pool_type: PoolType,
    pub head_zeroinit: bool,
    pub attn_chunk_size: usize,
}

Configuration for the Vision Transformer sensor encoder.

The encoder treats wearable sensor data as a 2-D grid (TIME_STEPS × NUM_CHANNELS) and divides it into rectangular patches of shape (patch_h × patch_w).

Fields

time_steps: usize

Number of time-steps in the input signal (default: 1440 = 24 h × 60 min).

num_channels: usize

Number of sensor channels (features) per time-step (default: 34).

patch_h: usize

Patch height (time axis), default: 10 minutes.

patch_w: usize

Patch width (channel axis), default: 2 channels.

d_model: usize

Transformer hidden dimension (ViT-B = 768).

depth: usize

Number of transformer layers (ViT-B = 12).

num_heads: usize

Number of attention heads per layer (ViT-B = 12).

mlp_dim: usize

Feed-forward MLP hidden dimension (ViT-B = 3072).

dropout: f64

Dropout probability applied inside each transformer block.

pool_type: PoolType

Type of sequence pooling used after the transformer. "map" (Multihead Attention Pooling) is the default and matches the reference implementation. "gap" (global average pooling) is a cheaper alternative.

head_zeroinit: bool

Whether to zero-initialise the output projection in the MAP head.

attn_chunk_size: usize

Chunked-attention window size (number of query rows per chunk).

Limits forward-pass peak attention memory from O(B·H·N²) to O(B·H·chunk·N) and keeps individual WGPU GPU dispatches small enough to avoid OS watchdog (TDR) timeouts.

⚠ Training caveat — chunking does NOT save backward memory. Burn’s autodiff tape records every intermediate tensor produced inside the chunk loop (q_chunk, scores, attn, chunk_out). All chunks for all layers are kept alive simultaneously until loss.backward() completes. True backward memory savings require gradient checkpointing, which is not yet implemented.

Rule of thumb for GPU VRAM (fp32, ViT-B, N = 2448, H = 12):

chunk	fwd attn @ B=4	fwd attn @ B=8
2448 (off)	4.3 GB	8.6 GB
256	450 MB	900 MB
128	225 MB	450 MB
64	112 MB	225 MB

Set to 0 to disable chunking (full N×N matrix — not recommended on GPU due to TDR risk and peak memory).

Default: 64.

Implementations

impl SensorEncoderConfig

pub fn num_patches(&self) -> usize

Total number of patches = (time_steps / patch_h) × (num_channels / patch_w).

Channel dimension is padded up to the next multiple of patch_w if num_channels is not evenly divisible.

Trait Implementations

impl Clone for SensorEncoderConfig

fn clone(&self) -> SensorEncoderConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SensorEncoderConfig

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

Formats the value using the given formatter.

impl Default for SensorEncoderConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SensorEncoderConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SensorEncoderConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.