intricate 0.7.0

A GPU accelerated library that creates/trains/runs machine learning prediction models in safe Rust code.
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

#[allow(unused_imports)]
use opencl3::error_codes::ClError;
#[allow(unused_imports)]
use crate::{
    layers::activations::TanH,
    layers::Dense,
    optimizers,
    loss_functions::MeanSquared,
    loss_functions::LossFunction,
    model::Model,
    types::{ModelLayer, TrainingVerbosity, TrainingOptions, HaltingCondition},
    utils::{setup_opencl, OpenCLState, opencl::DeviceType},
};

// Seems to fail every time I try to run this with DeviceType::CPU
// ending up with a bunch of NaN, no idea why, perhaps something with my drivers
// are wrong
#[test]
fn should_decrease_error() -> () {
    let layers: Vec<ModelLayer> = vec![
        Dense::new(2, 3),
        TanH::new (3),
        Dense::new(3, 1),
        TanH::new (1),
    ];

    let mut model = Model::new(layers);
    let opencl_state = setup_opencl(DeviceType::GPU).unwrap();
    model.init(&opencl_state).unwrap();

    let training_input_samples = vec![
        vec![0.0_f32, 0.0_f32],
        vec![1.0_f32, 0.0_f32],
        vec![0.0_f32, 1.0_f32],
        vec![1.0_f32, 1.0_f32],
    ];

    let training_output_samples = vec![
        vec![0.0_f32],
        vec![1.0_f32],
        vec![1.0_f32],
        vec![0.0_f32],
    ];


    let mut loss = MeanSquared::new();
    let mut optimizer = optimizers::Basic::new(0.1);

    // Fit the model however many times we want
    let training_results = model
        .fit(
            &training_input_samples,
            &training_output_samples,
            &mut TrainingOptions {
                loss_fn: &mut loss,
                verbosity: TrainingVerbosity {
                    show_current_epoch: false,
                    show_epoch_progress: false,
                    show_epoch_elapsed: false,
                    print_accuracy: false,
                    print_loss: false,
                    halting_condition_warning: false,
                },
                halting_condition: Some(HaltingCondition::MinLossReached(0.1)),
                compute_accuracy: true,
                compute_loss: true,
                optimizer: &mut optimizer,
                batch_size: 4,
                epochs: 10000,
            },
        )
        .unwrap();

    let max_loss = 0.1;
    let last_loss = training_results.loss_per_training_steps.last().unwrap();

    assert!(last_loss <= &max_loss);
}