native_neural_network_std 0.2.1

Ergonomic std wrapper for the `native_neural_network` crate (no_std) — std-friendly re-exports and utilities.
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

use native_neural_network_std as nn;
mod utils {
    include!("test_utils.rs");
}

#[test]
fn cpu_backend_abstraction_real() {
    let previous = native_neural_network_std::std::engine_std::get_compute_backend();
    native_neural_network_std::std::engine_std::set_compute_backend(
        native_neural_network_std::std::engine_std::ComputeBackend::Cpu,
    );
    assert_eq!(
        native_neural_network_std::std::engine_std::get_compute_backend(),
        native_neural_network_std::std::engine_std::ComputeBackend::Cpu
    );
    native_neural_network_std::std::engine_std::set_compute_backend(previous);
}

#[test]
fn fuzz_structured_random_networks() {
    let mut rng = utils::XorShift32::new(0xdeadbeef);
    for seed in 0..500u32 {
        let mut r = utils::XorShift32::new(seed.wrapping_add(rng.next_u32()));
        let layers_n = 2 + (r.next_u32() % 5) as usize;
        let mut layers = Vec::with_capacity(layers_n + 1);
        layers.push(1 + r.next_range_usize(16));
        for _ in 0..layers_n {
            layers.push(1 + r.next_range_usize(64));
        }
        let wcount =
            nn::std::network_std::NeuralNetworkStd::expected_weights_count(&layers).unwrap_or(0);
        let bcount =
            nn::std::network_std::NeuralNetworkStd::expected_biases_count(&layers).unwrap_or(0);
        if wcount == 0 {
            continue;
        }
        if wcount > 5_000_000 {
            continue;
        }
        let mut weights = vec![0f32; wcount];
        let mut biases = vec![0f32; bcount];
        for i in 0..wcount {
            weights[i] = r.next_f32() * 2.0;
        }
        for i in 0..bcount {
            biases[i] = r.next_f32();
        }
        let valid = nn::std::network_std::validate_network_parts(&layers, &weights, &biases);
        let _stats = nn::std::network_std::network_stats(&layers, &weights, &biases);
        if valid {
            let maybe = nn::std::network_std::NeuralNetworkStd::from_parts(
                layers.clone(),
                weights.clone(),
                biases.clone(),
            );
            if let Ok(net) = maybe {
                assert!(nn::std::network_std::validate_network_parts(
                    &layers,
                    &net.weights,
                    &net.biases
                ));
            }
        }
        assert!(
            utils::all_finite(&weights),
            "seed {} produced non-finite weight",
            seed
        );
        assert!(
            utils::all_finite(&biases),
            "seed {} produced non-finite bias",
            seed
        );
    }
}