Struct LevelEncoder 

pub struct LevelEncoder { /* private fields */ }

Encodes fixed-length numeric feature vectors into hypervectors.

Implementations

impl LevelEncoder

pub fn new( d: usize, n_features: usize, min: f64, max: f64, n_levels: usize, rng: &mut Rng, ) -> Self

Build an encoder for n_features values in [min, max], quantized to n_levels.

Examples found in repository

examples/clasificador.rs (line 24)

fn main() {
    let d = 10_000;
    let n_features = 16;
    let n_classes = 5;
    let mut rng = Rng::new(2025);

    let enc = LevelEncoder::new(d, n_features, 0.0, 1.0, 20, &mut rng);
    let means: Vec<Vec<f64>> = (0..n_classes)
        .map(|_| (0..n_features).map(|_| uni(&mut rng)).collect())
        .collect();

    // Train: just count bits per class.
    let mut clf = Classifier::new(d);
    for c in 0..n_classes {
        for _ in 0..50 {
            let s = sample(&means[c], &mut rng);
            clf.train(&enc.encode(&s), &format!("class{c}"));
        }
    }
    println!(
        "Trained {} classes by COUNTING BITS (no gradients, no epochs).",
        clf.n_classes()
    );

    // Serialize the model and reload it (deploy-once, use-many).
    let bytes = clf.build().save();
    let model = ItemMemory::load(&bytes).unwrap();
    println!("Model serialized to {} bytes and reloaded OK.", bytes.len());

    // Test accuracy.
    let per_class = 100;
    let mut correct = 0;
    for c in 0..n_classes {
        for _ in 0..per_class {
            let s = sample(&means[c], &mut rng);
            if model.cleanup(&enc.encode(&s)).unwrap().0 == format!("class{c}") {
                correct += 1;
            }
        }
    }
    let total = n_classes * per_class;
    println!(
        "Accuracy on {} test samples: {:.1}%",
        total,
        100.0 * correct as f64 / total as f64
    );
}

examples/digits.rs (line 33)

fn main() {
    // Dataset shipped with the crate: 64 pixel values (0..16) + label, per line.
    let csv = include_str!("data/digits.csv");
    let mut rows: Vec<(Vec<f64>, String)> = Vec::new();
    for line in csv.lines() {
        if line.trim().is_empty() {
            continue;
        }
        let mut nums: Vec<i64> = line.split(',').map(|t| t.trim().parse().unwrap()).collect();
        let label = nums.pop().unwrap().to_string();
        let features: Vec<f64> = nums.iter().map(|&v| v as f64).collect();
        rows.push((features, label));
    }

    // Deterministic shuffle, then a 70/30 train/test split.
    let mut rng = Rng::new(7);
    for k in (1..rows.len()).rev() {
        let j = (rng.next_u64() as usize) % (k + 1);
        rows.swap(k, j);
    }
    let n_train = rows.len() * 7 / 10;
    let (train, test) = rows.split_at(n_train);

    // Encode: 64 features, pixel intensity 0..16 quantized to 16 levels.
    let d = 10_000;
    let enc = LevelEncoder::new(d, 64, 0.0, 16.0, 16, &mut rng);

    let train_hv: Vec<Hypervector> = train.iter().map(|(f, _)| enc.encode(f)).collect();
    let train_labels: Vec<&str> = train.iter().map(|(_, l)| l.as_str()).collect();
    let test_hv: Vec<Hypervector> = test.iter().map(|(f, _)| enc.encode(f)).collect();
    let test_labels: Vec<&str> = test.iter().map(|(_, l)| l.as_str()).collect();

    let accuracy = |model: &ItemMemory| -> f64 {
        let correct = test_hv
            .iter()
            .zip(&test_labels)
            .filter(|(hv, &truth)| model.cleanup(hv).unwrap().0 == truth)
            .count();
        correct as f64 / test_hv.len() as f64
    };

    // One-shot training (single pass).
    let mut clf = Classifier::new(d);
    for (hv, &l) in train_hv.iter().zip(&train_labels) {
        clf.train(hv, l);
    }
    let acc_oneshot = accuracy(&clf.build());

    // Adaptive retraining.
    let mut clf2 = Classifier::new(d);
    clf2.fit(&train_hv, &train_labels, 20);
    let acc_retrained = accuracy(&clf2.build());

    println!(
        "Handwritten digits: {} train / {} test, 10 classes",
        train.len(),
        test.len()
    );
    println!("HDC one-shot      : {:.1}%", 100.0 * acc_oneshot);
    println!("HDC + retraining  : {:.1}%", 100.0 * acc_retrained);
}

pub fn encode(&self, features: &[f64]) -> Hypervector

Encode one feature vector (its length must equal n_features).

Examples found in repository

examples/clasificador.rs (line 34)

fn main() {
    let d = 10_000;
    let n_features = 16;
    let n_classes = 5;
    let mut rng = Rng::new(2025);

    let enc = LevelEncoder::new(d, n_features, 0.0, 1.0, 20, &mut rng);
    let means: Vec<Vec<f64>> = (0..n_classes)
        .map(|_| (0..n_features).map(|_| uni(&mut rng)).collect())
        .collect();

    // Train: just count bits per class.
    let mut clf = Classifier::new(d);
    for c in 0..n_classes {
        for _ in 0..50 {
            let s = sample(&means[c], &mut rng);
            clf.train(&enc.encode(&s), &format!("class{c}"));
        }
    }
    println!(
        "Trained {} classes by COUNTING BITS (no gradients, no epochs).",
        clf.n_classes()
    );

    // Serialize the model and reload it (deploy-once, use-many).
    let bytes = clf.build().save();
    let model = ItemMemory::load(&bytes).unwrap();
    println!("Model serialized to {} bytes and reloaded OK.", bytes.len());

    // Test accuracy.
    let per_class = 100;
    let mut correct = 0;
    for c in 0..n_classes {
        for _ in 0..per_class {
            let s = sample(&means[c], &mut rng);
            if model.cleanup(&enc.encode(&s)).unwrap().0 == format!("class{c}") {
                correct += 1;
            }
        }
    }
    let total = n_classes * per_class;
    println!(
        "Accuracy on {} test samples: {:.1}%",
        total,
        100.0 * correct as f64 / total as f64
    );
}

examples/digits.rs (line 35)

fn main() {
    // Dataset shipped with the crate: 64 pixel values (0..16) + label, per line.
    let csv = include_str!("data/digits.csv");
    let mut rows: Vec<(Vec<f64>, String)> = Vec::new();
    for line in csv.lines() {
        if line.trim().is_empty() {
            continue;
        }
        let mut nums: Vec<i64> = line.split(',').map(|t| t.trim().parse().unwrap()).collect();
        let label = nums.pop().unwrap().to_string();
        let features: Vec<f64> = nums.iter().map(|&v| v as f64).collect();
        rows.push((features, label));
    }

    // Deterministic shuffle, then a 70/30 train/test split.
    let mut rng = Rng::new(7);
    for k in (1..rows.len()).rev() {
        let j = (rng.next_u64() as usize) % (k + 1);
        rows.swap(k, j);
    }
    let n_train = rows.len() * 7 / 10;
    let (train, test) = rows.split_at(n_train);

    // Encode: 64 features, pixel intensity 0..16 quantized to 16 levels.
    let d = 10_000;
    let enc = LevelEncoder::new(d, 64, 0.0, 16.0, 16, &mut rng);

    let train_hv: Vec<Hypervector> = train.iter().map(|(f, _)| enc.encode(f)).collect();
    let train_labels: Vec<&str> = train.iter().map(|(_, l)| l.as_str()).collect();
    let test_hv: Vec<Hypervector> = test.iter().map(|(f, _)| enc.encode(f)).collect();
    let test_labels: Vec<&str> = test.iter().map(|(_, l)| l.as_str()).collect();

    let accuracy = |model: &ItemMemory| -> f64 {
        let correct = test_hv
            .iter()
            .zip(&test_labels)
            .filter(|(hv, &truth)| model.cleanup(hv).unwrap().0 == truth)
            .count();
        correct as f64 / test_hv.len() as f64
    };

    // One-shot training (single pass).
    let mut clf = Classifier::new(d);
    for (hv, &l) in train_hv.iter().zip(&train_labels) {
        clf.train(hv, l);
    }
    let acc_oneshot = accuracy(&clf.build());

    // Adaptive retraining.
    let mut clf2 = Classifier::new(d);
    clf2.fit(&train_hv, &train_labels, 20);
    let acc_retrained = accuracy(&clf2.build());

    println!(
        "Handwritten digits: {} train / {} test, 10 classes",
        train.len(),
        test.len()
    );
    println!("HDC one-shot      : {:.1}%", 100.0 * acc_oneshot);
    println!("HDC + retraining  : {:.1}%", 100.0 * acc_retrained);
}

pub fn dim(&self) -> usize

Hypervector dimension.