lace 0.9.1

A probabilistic cross-categorization engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#[cfg(feature = "bencher")]
fn main() {
    use std::env;

    use lace::bencher::Bencher;
    use lace::prelude::*;
    use lace::utils::mean;
    use lace::utils::std;

    let args: Vec<String> = env::args().skip(1).collect();

    let nrows: usize = args[0].parse().unwrap_or(250);
    let ncols: usize = args[1].parse().unwrap_or(20);

    println!("Running benchmark on {} x {} states", nrows, ncols);

    let coltype = ColType::Categorical {
        k: 3,
        hyper: None,
        value_map: lace::codebook::ValueMap::UInt(3),
        prior: None,
    };

    let state_buider = State::builder()
        .n_rows(nrows)
        .column_configs(ncols, coltype)
        .n_views(10)
        .n_cats(10);

    let config = StateUpdateConfig {
        transitions: vec![
            StateTransition::ColumnAssignment(ColAssignAlg::FiniteCpu),
            StateTransition::RowAssignment(RowAssignAlg::FiniteCpu),
            StateTransition::ComponentParams,
            StateTransition::FeaturePriors,
        ],
        ..Default::default()
    };

    let mut bencher = Bencher::from_builder(state_buider)
        .update_config(config)
        .n_iters(1)
        .n_runs(20);

    let mut rng = rand::rng();

    let result = bencher.run(&mut rng);

    let times_sec: Vec<f64> =
        result.iter().map(|res| res.time_sec[0]).collect();

    let mean_time = mean(&times_sec);
    let std_time = std(&times_sec);

    println!("Time (M, S) = ({}s, {}s)", mean_time, std_time);
}

#[cfg(not(feature = "bencher"))]
fn main() {
    eprintln!("Please enable the 'bencher' feature to use this example.")
}