Struct ReveEncoder 

pub struct ReveEncoder {
    pub model_cfg: ModelConfig,
    pub device: Device,
    /* private fields */
}

Fields

model_cfg: ModelConfig

device: Device

Implementations

impl ReveEncoder

pub fn load( config_path: &Path, weights_path: &Path, device: Device, ) -> Result<(Self, f64)>

Examples found in repository

examples/benchmark.rs (line 66)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let dev = parse_device(&args.device)?;
    let (config, weights) = locate_paths(args.config, args.weights)?;

    let (mut enc, _) = ReveEncoder::load(&config, &weights, dev)?;

    let n_chans = args.n_chans;
    let n_times = args.n_times;
    let signal = vec![0.0f32; n_chans * n_times];
    let positions = vec![0.0f32; n_chans * 3];

    for _ in 0..args.warmup {
        let out = enc.run_one(signal.clone(), positions.clone(), n_chans, n_times)?;
        anyhow::ensure!(
            out.output.iter().all(|v| v.is_finite()),
            "warmup produced non-finite values"
        );
    }

    let mut times = Vec::with_capacity(args.repeats);
    let mut last_dim = 0usize;
    for _ in 0..args.repeats {
        let t0 = Instant::now();
        let out = enc.run_one(signal.clone(), positions.clone(), n_chans, n_times)?;
        anyhow::ensure!(
            out.output.iter().all(|v| v.is_finite()),
            "run produced non-finite values"
        );
        last_dim = out.output.len();
        times.push(t0.elapsed().as_secs_f64() * 1000.0);
    }

    let times_str: Vec<String> = times.iter().map(|t| format!("{t:.4}")).collect();
    println!(
        "{{\"times_ms\": [{}], \"backend\": \"{}\", \"ok\": true, \"output_dim\": {}}}",
        times_str.join(", "),
        backend_name(dev),
        last_dim,
    );
    Ok(())
}

pub fn describe(&self) -> String

pub fn params(&self) -> &ParamMap

pub fn n_patches(&self) -> usize

pub fn prep_inputs( &self, signal: Vec<f32>, positions_xyz: &[f32], n_channels: usize, n_times: usize, ) -> Result<(Vec<f32>, Vec<f32>)>

CPU-side pre-processing: per-channel z-score on signal, then patch-extract [n_channels, n_patches, patch_size] (flat [n_chans*n_patches, patch_size]) and emit the 4-D position vectors [n_chans*n_patches, 4] (the 4th axis is patch index). Both outputs are inputs to the RLX graph.

pub fn run_at_layer( &mut self, signal: Vec<f32>, positions_xyz: Vec<f32>, n_channels: usize, n_times: usize, layer_end: usize, ) -> Result<ReveOutput>

Run REVE up to (but not including) layer_end of the transformer, returning the raw hidden state [s * embed_dim] flattened (s = n_channels * n_patches). Skips the final classification / attention-pool head. Caller is responsible for any downstream pooling. layer_end is clamped to depth.

Used for “intermediate-layer feature extraction” experiments where later layers may have specialised away from generic EEG structure.

pub fn run_one( &mut self, signal: Vec<f32>, positions_xyz: Vec<f32>, n_channels: usize, n_times: usize, ) -> Result<ReveOutput>

Examples found in repository

examples/benchmark.rs (line 74)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let dev = parse_device(&args.device)?;
    let (config, weights) = locate_paths(args.config, args.weights)?;

    let (mut enc, _) = ReveEncoder::load(&config, &weights, dev)?;

    let n_chans = args.n_chans;
    let n_times = args.n_times;
    let signal = vec![0.0f32; n_chans * n_times];
    let positions = vec![0.0f32; n_chans * 3];

    for _ in 0..args.warmup {
        let out = enc.run_one(signal.clone(), positions.clone(), n_chans, n_times)?;
        anyhow::ensure!(
            out.output.iter().all(|v| v.is_finite()),
            "warmup produced non-finite values"
        );
    }

    let mut times = Vec::with_capacity(args.repeats);
    let mut last_dim = 0usize;
    for _ in 0..args.repeats {
        let t0 = Instant::now();
        let out = enc.run_one(signal.clone(), positions.clone(), n_chans, n_times)?;
        anyhow::ensure!(
            out.output.iter().all(|v| v.is_finite()),
            "run produced non-finite values"
        );
        last_dim = out.output.len();
        times.push(t0.elapsed().as_secs_f64() * 1000.0);
    }

    let times_str: Vec<String> = times.iter().map(|t| format!("{t:.4}")).collect();
    println!(
        "{{\"times_ms\": [{}], \"backend\": \"{}\", \"ok\": true, \"output_dim\": {}}}",
        times_str.join(", "),
        backend_name(dev),
        last_dim,
    );
    Ok(())
}