Struct Coeffs

Source

pub struct Coeffs {
    pub p: Pyramid,
    pub c: Vec<f64>,
    pub w: Vec<f64>,
    pub cls: Vec<u8>,
    pub mean: f64,
}

Expand description

Forward-transformed, band-weighted coefficients.

Fields§

§p: Pyramid

Pyramid.

§c: Vec<f64>

Weighted coefficients (volume layout).

§w: Vec<f64>

Weight of each cell’s band.

§cls: Vec<u8>

Class of each cell’s band.

§mean: f64

Mean removed before the transform (keeps the LL band small).

Implementations§

Source §

impl Coeffs

Source

pub fn new(x: &[f64], dims: &[usize]) -> Self

Transform x with shape dims.

Examples found in repository ?

examples/analyze.rs (line 18)

6fn main() {
7    let a: Vec<String> = std::env::args().skip(1).collect();
8    let b = std::fs::read(&a[0]).unwrap();
9    let x: Vec<f64> = b
10        .as_chunks::<4>()
11        .0
12        .iter()
13        .map(|&c| f32::from_le_bytes(c) as f64)
14        .collect();
15    let dims: Vec<usize> = a[1].split('x').map(|s| s.parse().unwrap()).collect();
16    let delta: f64 = a[2].parse().unwrap();
17    let rho: f64 = a.get(3).map_or(0.45, |s| s.parse().unwrap());
18    let co = Coeffs::new(&x, &dims);
19    let (q, _) = quantize(&co, delta, rho);
20    let mut m = Meter::default();
21    let mut qq = q.clone();
22    let preds = if std::env::var("TC_NOPRED").is_ok() {
23        vec![]
24    } else {
25        fit_predictors(&co.p, &q)
26    };
27    code_bands(&co.p, &mut qq, &preds, &mut m, &mut HandModel::default());
28    let n = x.len() as f64;
29    let nz = q.iter().filter(|&&v| v != 0).count();
30    println!(
31        "nonzero {:.4}  sig {:.4} hi {:.4} low {:.4} sign {:.4}  total {:.4} bpv",
32        nz as f64 / n,
33        m.bits[0] / n,
34        m.bits[1] / n,
35        m.bits[2] / n,
36        m.bits[3] / n,
37        m.bits.iter().sum::<f64>() / n
38    );
39    // per band
40    for (bi, band) in co.p.bands.iter().enumerate() {
41        let _ = bi;
42        let [_, ny, nx] = co.p.dims;
43        let mut cnt = 0;
44        let mut nzc = 0;
45        let mut sa = 0u64;
46        for z in band.start[0]..band.end[0] {
47            for y in band.start[1]..band.end[1] {
48                for xx in band.start[2]..band.end[2] {
49                    let v = q[(z * ny + y) * nx + xx];
50                    cnt += 1;
51                    if v != 0 {
52                        nzc += 1;
53                    }
54                    sa += v.unsigned_abs() as u64;
55                }
56            }
57        }
58        if band.level <= 1 {
59            println!(
60                "  L{} m{:03b} n={} nz={:.3} mean|q|={:.2}",
61                band.level,
62                band.mask,
63                cnt,
64                nzc as f64 / cnt as f64,
65                sa as f64 / cnt as f64
66            );
67        }
68    }
69}

More examples

Hide additional examples

examples/pretrain.rs (line 52)

16fn main() {
17    let a: Vec<String> = std::env::args().skip(1).collect();
18    let out = &a[0];
19    let mut dims = vec![64, 128, 128];
20    let mut psnrs = vec![40.0, 60.0, 80.0, 100.0];
21    let mut cfg = TrainConfig::pretrain();
22    let mut per = 150_000usize;
23    let mut files = Vec::new();
24    let mut i = 1;
25    while i < a.len() {
26        match a[i].as_str() {
27            "--dims" => dims = a[i + 1].split('x').map(|s| s.parse().unwrap()).collect(),
28            "--psnr" => psnrs = a[i + 1].split(',').map(|s| s.parse().unwrap()).collect(),
29            "--hidden" => cfg.hidden = a[i + 1].split(',').map(|s| s.parse().unwrap()).collect(),
30            "--per" => per = a[i + 1].parse().unwrap(),
31            "--epochs" => cfg.epochs = a[i + 1].parse().unwrap(),
32            "--per-epoch" => cfg.per_epoch = a[i + 1].parse().unwrap(),
33            f => {
34                files.push(f.to_string());
35                i += 1;
36                continue;
37            }
38        }
39        i += 2;
40    }
41    let mut samples: Vec<Sample> = Vec::new();
42    let mut seed = 12345u64;
43    for f in &files {
44        let b = std::fs::read(f).unwrap();
45        let x: Vec<f32> = b
46            .as_chunks::<4>()
47            .0
48            .iter()
49            .map(|&c| f32::from_le_bytes(c))
50            .collect();
51        let xd: Vec<f64> = x.iter().map(|&v| v as f64).collect();
52        let co = Coeffs::new(&xd, &dims);
53        for &p in &psnrs {
54            let wc = WavConfig::new(ErrorBound::Psnr(p));
55            let (_, st) = encode_f32(&x, &dims, &wc);
56            let (q, _) = quantize(&co, st.delta, wc.rho);
57            let preds = fit_predictors(&co.p, &q);
58            let mut s = collect(&co.p, &q, &preds);
59            // seeded partial Fisher–Yates subsample
60            let k = per.min(s.len());
61            for j in 0..k {
62                seed = seed
63                    .wrapping_mul(6364136223846793005)
64                    .wrapping_add(1442695040888963407);
65                let r = j + (seed >> 11) as usize % (s.len() - j);
66                s.swap(j, r);
67            }
68            s.truncate(k);
69            eprintln!(
70                "{f} psnr {p}: delta {:.4e}, hand {:.4} bpv, {} samples",
71                st.delta,
72                st.bits_per_value,
73                s.len()
74            );
75            samples.extend(s);
76        }
77    }
78    let t = std::time::Instant::now();
79    let net = train(&samples, &cfg);
80    eprintln!(
81        "trained {} params on {} samples in {:.1}s: {:.4} bits/sample (float view)",
82        net.num_params(),
83        samples.len(),
84        t.elapsed().as_secs_f64(),
85        mean_bits_float(&net, &samples)
86    );
87    std::fs::write(out, Arc::new(net).to_bytes()).unwrap();
88    let _ = Net::from_bytes(&std::fs::read(out).unwrap()).unwrap();
89}