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
81
82
83
84
85
86
87

use burn::prelude::Backend;
use burn_store::{
    BurnpackStore,
    KeyRemapper,
    ModuleSnapshot,
};

use crate::{
    burner::module::ModuleInit,
    errors::{
        BunsenError,
        BunsenResult,
        WithOkOrPanic,
    },
    kits::speech::ten_vad::{
        TenVad,
        TenVadStructureConfig,
        reference,
    },
};

impl<B: Backend> TenVad<B> {
    /// Load the common pretrained `TenVAD` model.
    pub fn load_pretrained(device: &B::Device) -> BunsenResult<Self> {
        Self::load_from_burnpack_bytes(reference::burnpack_as_burn_bytes(), device)
    }

    /// The key remapping for the pretrained model.
    pub fn pretrained_mapper() -> KeyRemapper {
        KeyRemapper::from_patterns(vec![
            ("conv2d1", "cs1.blocks.0.conv"),
            ("conv2d2", "cs1.blocks.1.conv"),
            ("conv2d3", "cs2.blocks.0.conv"),
            ("conv2d4", "cs2.blocks.1.conv"),
            ("conv2d5", "cs2.blocks.2.conv"),
            ("conv2d6", "cs2.blocks.3.conv"),
            ("constant23", "linear1.bias"),
            ("constant27", "linear2.bias"),
        ])
        .ok_or_panic()
    }

    /// Load from pretrained burnpack bytes.
    pub fn load_from_burnpack_bytes(
        bytes: burn::tensor::Bytes,
        device: &B::Device,
    ) -> BunsenResult<Self> {
        Self::load_from_burnpack(
            BurnpackStore::from_bytes(Some(bytes)),
            TenVadStructureConfig::default(),
            Self::pretrained_mapper(),
            device,
        )
    }

    /// Load from a burnpack file.
    pub fn load_from_burnpack_file(
        path: impl AsRef<std::path::Path>,
        device: &B::Device,
    ) -> BunsenResult<Self> {
        Self::load_from_burnpack(
            BurnpackStore::from_file(path),
            TenVadStructureConfig::default(),
            Self::pretrained_mapper(),
            device,
        )
    }

    /// Load from a burnpack store.
    pub fn load_from_burnpack<C>(
        store: BurnpackStore,
        cfg: C,
        remapper: KeyRemapper,
        device: &B::Device,
    ) -> BunsenResult<Self>
    where
        C: ModuleInit<B, Self>,
    {
        let mut store = store.remap(remapper);
        let mut module = cfg.try_init(device)?;
        module
            .load_from(&mut store)
            .map_err(BunsenError::external)?;

        Ok(module)
    }
}