bunsen 0.29.1

bunsen is a batteries included common library for burn
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
80

#[cfg(test)]
mod test {
    use burn::tensor::{
        Distribution,
        Tensor,
        Tolerance,
        backend::BackendTypes,
    };

    use crate::{
        blocks::rnn::lstm::ExtLstmState,
        kits::speech::ten_vad::{
            TenVad,
            reference::ReferenceModel,
        },
        support::testing::PerformanceBackend,
    };

    #[test]
    #[serial_test::serial]
    #[allow(unused)]
    fn test_reference_model_forward_cross_test() {
        type B = PerformanceBackend;
        type F = <B as BackendTypes>::FloatElem;

        let device = Default::default();

        let ref_vad: ReferenceModel<B> = ReferenceModel::load_pretrained(&device);

        let vad: TenVad<B> = TenVad::load_pretrained(&device).unwrap();

        // TODO: batch support appears to be broken?
        let shape = [1, 64];

        let input = Tensor::random([1, 3, 41], Distribution::Default, &device);

        let state1_init = ExtLstmState::initial(shape, &device);
        let state2_init = ExtLstmState::initial(shape, &device);

        let (ref_prob, ref_lstm1_hidden, ref_lstm1_cell, ref_lstm2_hidden, ref_lstm2_cell) =
            ref_vad.forward(
                input.clone(),
                state1_init.hidden.clone(),
                state1_init.cell.clone(),
                state2_init.hidden.clone(),
                state2_init.cell.clone(),
            );

        let (mod_prob, mod_lstm1_state, mod_lstm2_state) = vad.forward(input.clone(), None, None);

        mod_prob
            .unsqueeze_dim::<3>(2)
            .to_data()
            .assert_approx_eq::<F>(&ref_prob.to_data(), Tolerance::permissive());

        mod_lstm1_state
            .hidden
            .clone()
            .to_data()
            .assert_approx_eq::<F>(&ref_lstm1_hidden.to_data(), Tolerance::permissive());

        mod_lstm1_state
            .cell
            .clone()
            .to_data()
            .assert_approx_eq::<F>(&ref_lstm1_cell.to_data(), Tolerance::permissive());

        mod_lstm2_state
            .hidden
            .clone()
            .to_data()
            .assert_approx_eq::<F>(&ref_lstm2_hidden.to_data(), Tolerance::permissive());

        mod_lstm2_state
            .cell
            .clone()
            .to_data()
            .assert_approx_eq::<F>(&ref_lstm2_cell.to_data(), Tolerance::permissive());
    }
}