newron 0.5.1

A Rust library to train and infer deep learning 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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#[cfg(test)]
mod metrics_tests {
    use newron::metrics::*;
    use newron::tensor::Tensor;
    use newron::utils;

    fn setup() -> (Tensor, Tensor) {
        let predictions: Tensor = Tensor::new(vec![0.4, 0.6, 
                                                   0.1, 0.9, 
                                                   0.3, 0.7, 
                                                   1.0, 0.0], vec![4, 2]);

        let true_values: Tensor = Tensor::new(vec![0.4, 0.6, 
                                                   0.1, 0.9, 
                                                   0.7, 0.3, 
                                                   1.0, 0.0], vec![4, 2]);
        (true_values, predictions)
    }

    #[test]
    fn test_cm() {
        let (y_true, y_pred) = setup();

        let cm = confusion_matrix::ConfusionMatrix::new(y_true.clone(), 
                                                        y_pred.clone());

        let result = vec![vec![1, 1], vec![0, 2]];
        assert_eq!(cm.data, result);
    }


    #[test]
    fn test_accuracy() {
        let (y_true, y_pred) = setup();

        let cm = confusion_matrix::ConfusionMatrix::new(y_true.clone(), 
                                                        y_pred.clone());

        let acc_score = cm.accuracy_score();
        let result = 0.75;
        assert_eq!(utils::round_f64(acc_score, 2), result);
    }

    #[test]
    fn test_recall() {
        let (y_true, y_pred) = setup();

        let cm = confusion_matrix::ConfusionMatrix::new(y_true.clone(), 
                                                        y_pred.clone());

        let rec_score = cm.recall_score(1);
        let result = 0.7;
        assert_eq!(utils::round_f64(rec_score, 1), result);
    }

    #[test]
    fn test_precision() {
        let (y_true, y_pred) = setup();

        let cm = confusion_matrix::ConfusionMatrix::new(y_true.clone(), 
                                                        y_pred.clone());

        let pre_score = cm.precision_score(1);
        let result = 1.0;
        assert_eq!(utils::round_f64(pre_score, 1), result);
    }

    #[test]
    fn test_f1() {
        let (y_true, y_pred) = setup();

        let cm = confusion_matrix::ConfusionMatrix::new(y_true.clone(), 
                                                        y_pred.clone());

        let f1_score = cm.f1_score(1);
        let result = 0.8;
        assert_eq!(utils::round_f64(f1_score, 1), result);
    }
}