vikos 0.3.1

A machine learning library for supervised training of parametrized models
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

/// Multiclass analyses of the iris dataset build on binary logistic classifaction
///
/// Also demonstrates online training, and usage of custom feature type
use vikos::{Crisp, Model, Teacher};

const PATH: &'static str = "examples/data/iris.csv";

type Features = Vec<f64>;

fn main() {
    let teacher = vikos::teacher::Nesterov {
        l0: 0.0001,
        t: 1000.0,
        inertia: 0.99,
    };
    let cost = vikos::cost::MaxLikelihood {};

    // Train three individual three Logistic models, one for each class of Iris.
    let mut model = vikos::model::OneVsRest::new([
        vikos::model::Logistic::with_feature_dimension(4),
        vikos::model::Logistic::with_feature_dimension(4),
        vikos::model::Logistic::with_feature_dimension(4),
    ]);

    // Each of the classifieres has its own training state
    let mut training = teacher.new_training(&model);

    // Read iris Data
    for epoch in 0..300 {
        let mut rdr = csv::Reader::from_path(PATH).expect("File is ok");
        let mut hit = 0;
        let mut miss = 0;

        for row in rdr.deserialize() {
            // Learn event
            let (truth, features): (String, Features) = row.unwrap();

            let class = match truth.as_ref() {
                "setosa" => 0,
                "versicolor" => 1,
                "virginica" => 2,
                _ => panic!("unknown Iris class: {}", truth),
            };

            teacher.teach_event(&mut training, &mut model, &cost, &features, class);

            // Make prediction using current expertise
            let prediction = model.predict(&features).crisp();

            if prediction == class {
                hit += 1;
            } else {
                miss += 1;
            }
        }
        let accuracy = hit as f64 / (hit + miss) as f64;

        println!("epoch: {}, accuracy: {}", epoch, accuracy);
    }
}