Struct EncodingResult 

pub struct EncodingResult {
    pub epochs: Vec<EpochEmbedding>,
    pub ms_load: f64,
    pub ms_encode: f64,
}

Collection of per-epoch outputs.

Fields

epochs: Vec<EpochEmbedding>

ms_load: f64

ms_encode: f64

Implementations

impl EncodingResult

pub fn save_safetensors(&self, path: &str) -> Result<()>

Save to safetensors file.

Examples found in repository

examples/embed.rs (line 127)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let t0 = Instant::now();
    let device = backend::device();

    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║  OSF — PSG Embedding Extraction                             ║");
    println!("╚══════════════════════════════════════════════════════════════╝\n");

    // 1. Load model
    let model_cfg = if let Some(ref cfg_path) = args.config {
        let cfg_str = std::fs::read_to_string(cfg_path)?;
        serde_json::from_str(&cfg_str)?
    } else {
        osf_rs::ModelConfig::default()
    };

    println!("▸ Loading OSF model …");
    let (encoder, ms_load) = osf_rs::OsfEncoder::<B>::load_with_config(
        model_cfg,
        Path::new(&args.weights),
        device.clone(),
    )?;
    println!("  {}  ({ms_load:.0} ms)\n", encoder.describe());

    // 2. Generate synthetic PSG epochs
    let n_channels = osf_rs::NUM_PSG_CHANNELS;
    let n_samples = osf_rs::EPOCH_SAMPLES;
    let n_epochs = 3;

    println!("▸ Generating {} synthetic PSG epochs ({} ch × {} samples each)\n",
        n_epochs, n_channels, n_samples);

    let mut all_outputs = Vec::new();

    for epoch_idx in 0..n_epochs {
        let signal = generate_synthetic_psg(n_channels, n_samples);
        let batch = osf_rs::build_batch::<B>(signal, n_channels, n_samples, &device);

        let t = Instant::now();
        let result = encoder.run_batch(&batch)?;
        let ms = t.elapsed().as_secs_f64() * 1000.0;

        // Stats
        let cls = &result.cls_emb;
        let mean: f64 = cls.iter().map(|&v| v as f64).sum::<f64>() / cls.len() as f64;
        let std: f64 = (cls.iter().map(|&v| { let d = v as f64 - mean; d * d }).sum::<f64>()
            / cls.len() as f64).sqrt();

        println!("  Epoch {epoch_idx}: cls=[{}]  patches=[{},{}]  mean={mean:+.4}  std={std:.4}  {ms:.1}ms",
            result.embed_dim, result.num_patches, result.embed_dim);

        if args.verbose && epoch_idx == 0 {
            println!("    First 5 CLS values: {:?}", &cls[..5.min(cls.len())]);
        }

        all_outputs.push(result);
    }

    // 3. Save
    let encoding = osf_rs::EncodingResult {
        epochs: all_outputs,
        ms_load,
        ms_encode: t0.elapsed().as_secs_f64() * 1000.0,
    };

    if let Some(p) = Path::new(&args.output).parent() {
        std::fs::create_dir_all(p)?;
    }
    encoding.save_safetensors(&args.output)?;
    println!("\n▸ Saved {} epochs → {}", n_epochs, args.output);

    let ms_total = t0.elapsed().as_secs_f64() * 1000.0;
    println!("\n  Total: {ms_total:.0} ms");
    Ok(())
}