use burn::{
Tensor,
config::Config,
module::Module,
tensor::Device,
};
use crate::{
errors::{
BunsenError,
BunsenResult,
ConstraintError,
WithOkOrPanic,
},
kits::speech::vad::silero_vad::SileroVad,
};
pub trait SileroVadContextMeta {
fn sample_rate(&self) -> usize;
fn batch_size(&self) -> usize;
fn context_size(&self) -> usize;
}
#[derive(Config, Debug)]
pub struct SileroVadContextConfig {
pub sample_rate: usize,
#[config(default = "1")]
pub batch_size: usize,
#[config(default = "Self::default_context_size(sample_rate)")]
pub context_size: usize,
}
impl SileroVadContextMeta for SileroVadContextConfig {
fn sample_rate(&self) -> usize {
self.sample_rate
}
fn batch_size(&self) -> usize {
self.batch_size
}
fn context_size(&self) -> usize {
self.context_size
}
}
#[derive(Module, Debug)]
pub struct SileroVadContext {
pub sample_rate: usize,
pub context: Tensor<2>,
pub state: Tensor<3>,
}
impl SileroVadContextMeta for SileroVadContext {
fn sample_rate(&self) -> usize {
self.sample_rate
}
fn batch_size(&self) -> usize {
self.context.dims()[0]
}
fn context_size(&self) -> usize {
self.context.dims()[1]
}
}
impl SileroVadContextConfig {
pub fn default_context_size(sample_rate: usize) -> usize {
sample_rate / 250
}
pub fn try_init(
&self,
vad: &SileroVad,
device: &Device,
) -> BunsenResult<SileroVadContext> {
if self.context_size == 0 {
return Err(BunsenError::from(ConstraintError::zero_or_empty(
"SileroVadContextConfig",
"context_size",
))
.with_details(format!(
"the default, sample_rate / 250, is 0 below 250 Hz; sample_rate = {}",
self.sample_rate,
)));
}
Ok(vad.init_context(self.batch_size, self.context_size, device))
}
pub fn init(
&self,
vad: &SileroVad,
device: &Device,
) -> SileroVadContext {
self.try_init(vad, device).ok_or_panic()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
burner::module::ModuleInit,
errors::{
BunsenErrorKind,
testing::ErrorMatcher,
},
kits::speech::vad::silero_vad::SileroVadSignalConfig,
support::testing::performance_device,
};
#[test]
fn test_default_context_size_is_upstreams() {
assert_eq!(SileroVadContextConfig::new(16000).context_size(), 64);
assert_eq!(SileroVadContextConfig::new(8000).context_size(), 32);
}
#[test]
#[serial_test::serial]
fn test_try_init_refuses_a_zero_context() {
let device = performance_device();
let vad_at = |rate: usize| -> SileroVad {
SileroVadSignalConfig::new(rate, 33)
.with_d_hidden(32)
.with_d_bottleneck(16)
.init(&device)
};
for cfg in [
SileroVadContextConfig::new(16000).with_context_size(0),
SileroVadContextConfig::new(249),
SileroVadContextConfig::new(0),
] {
assert_eq!(cfg.context_size(), 0);
ErrorMatcher::kind(BunsenErrorKind::Illegal)
.has_cause::<ConstraintError>()
.assert_err(&cfg.try_init(&vad_at(cfg.sample_rate), &device));
}
let cfg = SileroVadContextConfig::new(250);
assert_eq!(cfg.context_size(), 1);
let context = cfg.try_init(&vad_at(250), &device).unwrap();
assert_eq!(context.context.dims(), [1, 1]);
}
}