rail 0.3.1

A GPU-Accelerated ML Library akin to Keras
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

use crate::Matrix;
pub type LossFuntion = Fn(&Matrix, &Matrix) -> f64;
pub type DLossFuntion = Fn(&Matrix, &Matrix) -> Matrix;
pub type LossFuntionGenerator = Fn() -> (Box<LossFuntion>, Box<DLossFuntion>);

pub fn mean_squared_error() -> (Box<LossFuntion>, Box<DLossFuntion>){
    let mse = |output: &Matrix, expected: &Matrix| {
        let diff = arrayfire::sub(expected, output, true);
        let squared = &diff * &diff;
        let mean = arrayfire::mean(&squared, 0);
        let result = mean * 0.5f64;
        use crate::utils::array_data;
        return array_data(result).iter().sum();
    };

    let d_mse = |output: &Matrix, expected: &Matrix| {
        let diff = arrayfire::sub(expected, output, true);
        let sum = arrayfire::sum(&diff, 0);

        sum
    };

    (Box::new(mse), Box::new(d_mse))
}

#[cfg(test)]
mod tests {
    use super::*;
    use arrayfire::Dim4;
    use crate::utils::array_data;

    #[test]
    fn mse_test() {
        let input = Matrix::new(&[1.0, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[-0.5, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let (mse, _) = mean_squared_error();

        let output = mse(&input, &expected);
        assert_eq!(output, 0.375);

        let input = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));

        let output = mse(&input, &expected);
        assert_eq!(output, 0.0);

        let input = Matrix::new(&[0.0, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));

        let output = mse(&input, &expected);
        assert_eq!(output, 0.5);
    }

    #[test]
    fn d_mse_test() {
        let output = Matrix::new(&[-0.5, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[1.0, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let (_, d_mse) = mean_squared_error();

        let output = d_mse(&output, &expected);
        let data = array_data(output);
        assert_eq!(data, vec![1.5]);

        let output = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));

        let output = d_mse(&output, &expected);
        let data = array_data(output);
        assert_eq!(data, vec![0.0]);

        let output = Matrix::new(&[0.0, 0.0, 0.0], Dim4::new(&[3, 1, 1, 1]));
        let expected = Matrix::new(&[1.0, 1.0, 1.0], Dim4::new(&[3, 1, 1, 1]));

        let output = d_mse(&output, &expected);
        let data = array_data(output);
        assert_eq!(data, vec![3.0]);
    }
}