use burn::config::Config;
use crate::errors::{
BunsenResult,
ConstraintError,
Rule,
};
#[derive(Config, Debug, PartialEq)]
pub struct SortformerStreamingConfig {
pub chunk_len: usize,
pub right_context: usize,
#[config(default = "0")]
pub left_context: usize,
pub fifo_len: usize,
pub spkcache_len: usize,
pub update_period: usize,
#[config(default = "1")]
pub silence_frames_per_speaker: usize,
#[config(default = "0.25")]
pub pred_score_threshold: f64,
#[config(default = "0.05")]
pub latest_boost: f64,
#[config(default = "0.75")]
pub strong_boost_rate: f64,
#[config(default = "1.5")]
pub weak_boost_rate: f64,
#[config(default = "0.5")]
pub min_pos_scores_rate: f64,
#[config(default = "0.2")]
pub silence_threshold: f64,
}
impl SortformerStreamingConfig {
pub fn latency_frames(&self) -> usize {
self.chunk_len + self.right_context
}
pub fn speaker_budget(
&self,
n_speakers: usize,
) -> usize {
(self.spkcache_len / n_speakers).saturating_sub(self.silence_frames_per_speaker)
}
pub fn check(
&self,
n_speakers: usize,
) -> BunsenResult<()> {
for (field, value) in [
("chunk_len", self.chunk_len),
("update_period", self.update_period),
] {
if value == 0 {
return Err(
ConstraintError::zero_or_empty("SortformerStreamingConfig", field).into(),
);
}
}
let least = (1 + self.silence_frames_per_speaker) * n_speakers;
if self.spkcache_len < least {
return Err(ConstraintError::new(
"SortformerStreamingConfig",
"spkcache_len",
Rule::Relation {
lhs: ("spkcache_len".into(), self.spkcache_len.to_string()),
op: ">=",
rhs: (
"(1 + silence_frames_per_speaker) * n_speakers".into(),
least.to_string(),
),
},
)
.into());
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SortformerFamily {
Nemotron,
SortformerV2,
}
impl SortformerFamily {
pub fn template_class(self) -> &'static str {
match self {
Self::Nemotron => "nvidia/sortformer/nemotron",
Self::SortformerV2 => "nvidia/sortformer/sortformer-v2",
}
}
}
impl core::fmt::Display for SortformerFamily {
fn fmt(
&self,
f: &mut core::fmt::Formatter<'_>,
) -> core::fmt::Result {
f.write_str(match self {
Self::Nemotron => "Nemotron-3-Diarization",
Self::SortformerV2 => "Sortformer v2",
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_template_class() {
assert_eq!(
SortformerFamily::Nemotron.template_class(),
"nvidia/sortformer/nemotron"
);
assert_eq!(
SortformerFamily::SortformerV2.template_class(),
"nvidia/sortformer/sortformer-v2"
);
for family in [SortformerFamily::Nemotron, SortformerFamily::SortformerV2] {
crate::data::catalog::BuiltinCatalog::get()
.unwrap()
.template_presets(family.template_class())
.unwrap();
}
}
#[test]
fn test_check() {
let c = SortformerStreamingConfig::new(3, 1, 6, 12, 4);
c.check(3).unwrap();
assert!(c.check(7).is_err());
let empty_chunk = SortformerStreamingConfig {
chunk_len: 0,
..c.clone()
};
assert!(empty_chunk.check(3).is_err());
let no_period = SortformerStreamingConfig {
update_period: 0,
..c
};
assert!(no_period.check(3).is_err());
}
}