Function mean_bits_float 

pub fn mean_bits_float(net: &Net, samples: &[Sample]) -> f64

Mean ideal code length (bits/sample) of samples under the float view of an integer net (for reporting; the coder’s actual bits include binarization and probability rounding).

Examples found in repository

examples/pretrain3.rs (line 70)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let out = &args[0];
    let hidden: Vec<usize> = opt(&args, "--hidden", "32,16")
        .split(',')
        .map(|v| v.parse().unwrap())
        .collect();
    let psnr: Vec<f64> = opt(&args, "--psnr", "40,50,60,70,80,90,100")
        .split(',')
        .map(|v| v.parse().unwrap())
        .collect();
    let lanes: usize = opt(&args, "--lanes", "8").parse().unwrap();
    let block: usize = opt(&args, "--block", "32").parse().unwrap();
    let per: usize = opt(&args, "--per", "100000").parse().unwrap();
    let epochs: usize = opt(&args, "--epochs", "8").parse().unwrap();
    let mut smp = Vec::new();
    for a in args.iter().filter(|a| a.contains(".f32:")) {
        let (path, d) = a.split_once(':').unwrap();
        let dims: Vec<usize> = d.split('x').map(|s| s.parse().unwrap()).collect();
        let b = std::fs::read(path).unwrap();
        let x: Vec<f32> = b
            .as_chunks::<4>()
            .0
            .iter()
            .map(|&c| f32::from_le_bytes(c))
            .collect();
        for &p in &psnr {
            let cfg = Gpu3Config {
                block,
                block2d: block * 4,
                lanes,
                ..Gpu3Config::new(ErrorBound::Psnr(p))
            };
            let s = samples3(&x, &dims, &cfg, 16, per);
            eprintln!("{path} {p} dB: {} samples", s.len());
            smp.extend(s);
        }
    }
    let tc = TrainConfig {
        hidden,
        epochs,
        per_epoch: 3_000_000,
        batch: 256,
        lr: 3e-3,
        apm: false,
        seed: 7,
    };
    let t = std::time::Instant::now();
    let net = train(&smp, &tc);
    eprintln!(
        "trained on {} samples in {:.1}s: {:.4} bits/sample (float view), {} params",
        smp.len(),
        t.elapsed().as_secs_f64(),
        mean_bits_float(&net, &smp),
        net.num_params()
    );
    std::fs::write(out, net.to_bytes()).unwrap();
}

examples/pretrain.rs (line 85)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let out = &a[0];
    let mut dims = vec![64, 128, 128];
    let mut psnrs = vec![40.0, 60.0, 80.0, 100.0];
    let mut cfg = TrainConfig::pretrain();
    let mut per = 150_000usize;
    let mut files = Vec::new();
    let mut i = 1;
    while i < a.len() {
        match a[i].as_str() {
            "--dims" => dims = a[i + 1].split('x').map(|s| s.parse().unwrap()).collect(),
            "--psnr" => psnrs = a[i + 1].split(',').map(|s| s.parse().unwrap()).collect(),
            "--hidden" => cfg.hidden = a[i + 1].split(',').map(|s| s.parse().unwrap()).collect(),
            "--per" => per = a[i + 1].parse().unwrap(),
            "--epochs" => cfg.epochs = a[i + 1].parse().unwrap(),
            "--per-epoch" => cfg.per_epoch = a[i + 1].parse().unwrap(),
            f => {
                files.push(f.to_string());
                i += 1;
                continue;
            }
        }
        i += 2;
    }
    let mut samples: Vec<Sample> = Vec::new();
    let mut seed = 12345u64;
    for f in &files {
        let b = std::fs::read(f).unwrap();
        let x: Vec<f32> = b
            .as_chunks::<4>()
            .0
            .iter()
            .map(|&c| f32::from_le_bytes(c))
            .collect();
        let xd: Vec<f64> = x.iter().map(|&v| v as f64).collect();
        let co = Coeffs::new(&xd, &dims);
        for &p in &psnrs {
            let wc = WavConfig::new(ErrorBound::Psnr(p));
            let (_, st) = encode_f32(&x, &dims, &wc);
            let (q, _) = quantize(&co, st.delta, wc.rho);
            let preds = fit_predictors(&co.p, &q);
            let mut s = collect(&co.p, &q, &preds);
            // seeded partial Fisher–Yates subsample
            let k = per.min(s.len());
            for j in 0..k {
                seed = seed
                    .wrapping_mul(6364136223846793005)
                    .wrapping_add(1442695040888963407);
                let r = j + (seed >> 11) as usize % (s.len() - j);
                s.swap(j, r);
            }
            s.truncate(k);
            eprintln!(
                "{f} psnr {p}: delta {:.4e}, hand {:.4} bpv, {} samples",
                st.delta,
                st.bits_per_value,
                s.len()
            );
            samples.extend(s);
        }
    }
    let t = std::time::Instant::now();
    let net = train(&samples, &cfg);
    eprintln!(
        "trained {} params on {} samples in {:.1}s: {:.4} bits/sample (float view)",
        net.num_params(),
        samples.len(),
        t.elapsed().as_secs_f64(),
        mean_bits_float(&net, &samples)
    );
    std::fs::write(out, Arc::new(net).to_bytes()).unwrap();
    let _ = Net::from_bytes(&std::fs::read(out).unwrap()).unwrap();
}