burn-tensor 0.18.0

Tensor library with user-friendly APIs and automatic differentiation support
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

#[burn_tensor_testgen::testgen(var)]
mod tests {
    use super::*;
    use burn_tensor::backend::Backend;
    use burn_tensor::{Tensor, TensorData};

    type FloatElem = <TestBackend as Backend>::FloatElem;
    type IntElem = <TestBackend as Backend>::IntElem;

    use burn_tensor::Tolerance;

    #[test]
    fn test_var() {
        let tensor = TestTensor::<2>::from_data(
            [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
            &Default::default(),
        );

        let output = tensor.var(1);
        let expected = TensorData::from([[2.4892], [15.3333]]).convert::<FloatElem>();

        output
            .into_data()
            .assert_approx_eq::<FloatElem>(&expected, Tolerance::default());
    }

    #[test]
    fn test_var_mean() {
        let tensor = TestTensor::<2>::from_data(
            [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
            &Default::default(),
        );

        let (var, mean) = tensor.var_mean(1);

        let var_expected = TensorData::from([[2.4892], [15.3333]]).convert::<FloatElem>();
        let mean_expected = TensorData::from([[0.125], [1.]]).convert::<FloatElem>();

        var.into_data()
            .assert_approx_eq::<FloatElem>(&var_expected, Tolerance::default());
        mean.into_data()
            .assert_approx_eq::<FloatElem>(&mean_expected, Tolerance::default());
    }

    #[test]
    fn test_var_bias() {
        let tensor = TestTensor::<2>::from_data(
            [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
            &Default::default(),
        );

        let output = tensor.var_bias(1);
        let expected = TensorData::from([[1.86688], [11.5]]).convert::<FloatElem>();

        output
            .into_data()
            .assert_approx_eq::<FloatElem>(&expected, Tolerance::default());
    }

    #[test]
    fn test_var_mean_bias() {
        let tensor = TestTensor::<2>::from_data(
            [[0.5, 1.8, 0.2, -2.0], [3.0, -4.0, 5.0, 0.0]],
            &Default::default(),
        );

        let (var, mean) = tensor.var_mean_bias(1);

        let var_expected = TensorData::from([[1.86688], [11.5]]).convert::<FloatElem>();
        let mean_expected = TensorData::from([[0.125], [1.]]).convert::<FloatElem>();

        var.into_data()
            .assert_approx_eq::<FloatElem>(&var_expected, Tolerance::default());
        mean.into_data()
            .assert_approx_eq::<FloatElem>(&mean_expected, Tolerance::default());
    }
}