ffsvm 0.12.0

A libSVM compatible support vector machine, but up to 10x faster, for games or VR.
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#![feature(test)]

// This is a little weird, see
// https://github.com/rust-lang/rust/pull/54116#issuecomment-422294107
// for details
extern crate test;

mod util;

mod svm_sparse {
    use crate::test::Bencher;
    use ffsvm::{FeatureVector, Predict, SparseSVM};
    use std::convert::TryFrom;

    /// Produces a test case run for benchmarking
    #[allow(dead_code)]
    fn produce_testcase(svm_type: &str, kernel_type: &str, total_sv: u32, num_attributes: u32) -> impl FnMut() {
        let raw_model = super::util::random_dense(svm_type, kernel_type, total_sv, num_attributes);
        let svm = SparseSVM::try_from(&raw_model).unwrap();
        let mut problem = FeatureVector::from(&svm);
        let problem_mut = problem.features();

        for i in 0..num_attributes {
            problem_mut[i as usize] = i as f32;
        }

        move || svm.predict_value(&mut problem).expect("This should work")
    }

    // RBF

    #[bench]
    fn predict_rbf_sv128_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "rbf", 128, 16));
    }

    #[bench]
    fn predict_rbf_sv1024_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "rbf", 1024, 16));
    }

    #[bench]
    fn predict_rbf_sv1024_attr1024(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "rbf", 1024, 1024));
    }

    // Linear

    #[bench]
    fn predict_linear_sv128_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "linear", 128, 16));
    }

    #[bench]
    fn predict_linear_sv1024_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "linear", 1024, 16));
    }

    #[bench]
    fn predict_linear_sv1024_attr1024(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "linear", 1024, 1024));
    }

    // Poly

    #[bench]
    fn predict_poly_sv128_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "polynomial", 128, 16));
    }

    #[bench]
    fn predict_poly_sv1024_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "polynomial", 1024, 16));
    }

    #[bench]
    fn predict_poly_sv1024_attr1024(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "polynomial", 1024, 1024));
    }

    // Sigmoid

    #[bench]
    fn predict_sigmoid_sv128_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "sigmoid", 128, 16));
    }

    #[bench]
    fn predict_sigmoid_sv1024_attr16(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 16));
    }

    #[bench]
    fn predict_sigmoid_sv1024_attr1024(b: &mut Bencher) {
        b.iter(produce_testcase("c_svc", "sigmoid", 1024, 1024));
    }
}