use core::fmt::Debug;
use crate::kits::speech::diarization::{
SpeakerActivity,
TurnFilterConfig,
};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SpeakerLabel {
pub index: usize,
pub confidence: f32,
}
pub trait SpeakerAttribution: Debug + Send + Sync {
fn attribute(
&self,
activity: &SpeakerActivity,
start: usize,
end: usize,
) -> Option<SpeakerLabel>;
}
fn overlapping(
activity: &SpeakerActivity,
start: usize,
end: usize,
lead: usize,
) -> core::ops::Range<usize> {
if activity.is_empty() || end <= start {
return 0..0;
}
let f = activity.frame_samples;
let first = (start.saturating_sub(activity.start) / f).saturating_sub(lead);
let last = end
.saturating_sub(activity.start)
.div_ceil(f)
.min(activity.frames());
first.min(last)..last
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct MeanActivity {
pub lead_frames: usize,
}
impl SpeakerAttribution for MeanActivity {
fn attribute(
&self,
activity: &SpeakerActivity,
start: usize,
end: usize,
) -> Option<SpeakerLabel> {
let frames = overlapping(activity, start, end, self.lead_frames);
if frames.is_empty() {
return None;
}
let n = frames.len() as f32;
let mut means = vec![0.0f32; activity.n_speakers];
for i in frames {
for (m, p) in means.iter_mut().zip(activity.frame(i)) {
*m += p / n;
}
}
for m in &mut means {
*m = m.max(0.01);
}
let total: f32 = means.iter().sum();
let (index, &best) = means
.iter()
.enumerate()
.max_by(|a, b| a.1.total_cmp(b.1))
.expect("at least one speaker");
Some(SpeakerLabel {
index,
confidence: best / total,
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TurnOverlap {
pub filter: TurnFilterConfig,
}
impl SpeakerAttribution for TurnOverlap {
fn attribute(
&self,
activity: &SpeakerActivity,
start: usize,
end: usize,
) -> Option<SpeakerLabel> {
let frames = overlapping(activity, start, end, 0);
if frames.is_empty() {
return None;
}
let s = activity.n_speakers;
let f = activity.frame_samples as f64;
let origin = (activity.start + frames.start * activity.frame_samples) as f64;
let probs = &activity.probs[frames.start * s..frames.end * s];
let turns = self.filter.turns(probs, s, 1.0);
let (lo, hi) = (start as f64, end as f64);
let mut covered = vec![0.0f64; s];
for t in turns {
let (a, b) = (origin + t.start * f, origin + t.end * f);
covered[t.speaker] += (b.min(hi) - a.max(lo)).max(0.0);
}
let (index, &best) = covered
.iter()
.enumerate()
.max_by(|a, b| a.1.total_cmp(b.1))
.expect("at least one speaker");
(best > 0.0).then(|| SpeakerLabel {
index,
confidence: (best / (hi - lo)).min(1.0) as f32,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn activity() -> SpeakerActivity {
let mut probs = Vec::new();
for i in 0..8 {
probs.extend(if i < 4 { [0.9, 0.1] } else { [0.05, 0.8] });
}
SpeakerActivity::try_new(100, 10, 2, probs).unwrap()
}
#[test]
fn test_mean_activity_follows_the_frames() {
let rule = MeanActivity::default();
let a = activity();
assert_eq!(rule.attribute(&a, 100, 140).unwrap().index, 0);
assert_eq!(rule.attribute(&a, 145, 180).unwrap().index, 1);
let mixed = rule.attribute(&a, 125, 180).unwrap();
assert_eq!(mixed.index, 1);
let pure = rule.attribute(&a, 140, 180).unwrap();
assert!(mixed.confidence < pure.confidence);
assert!((rule.attribute(&a, 100, 140).unwrap().confidence - 0.9).abs() < 1e-6);
}
#[test]
fn test_lead_frames_reach_back() {
let a = activity();
assert_eq!(
MeanActivity::default()
.attribute(&a, 140, 150)
.unwrap()
.index,
1
);
let rule = MeanActivity { lead_frames: 2 };
assert_eq!(rule.attribute(&a, 140, 150).unwrap().index, 0);
}
#[test]
fn test_nothing_covered_is_nobody() {
let a = activity();
assert!(MeanActivity::default().attribute(&a, 300, 400).is_none());
assert!(MeanActivity::default().attribute(&a, 120, 120).is_none());
let empty = SpeakerActivity::empty(0, 10, 2);
assert!(MeanActivity::default().attribute(&empty, 0, 50).is_none());
}
#[test]
fn test_turn_overlap() {
let rule = TurnOverlap::default();
let a = activity();
let label = rule.attribute(&a, 120, 180).unwrap();
assert_eq!(label.index, 1);
assert!((label.confidence - 40.0 / 60.0).abs() < 1e-6);
let label = rule.attribute(&a, 100, 130).unwrap();
assert_eq!(label.index, 0);
assert!((label.confidence - 1.0).abs() < 1e-6);
let quiet = SpeakerActivity::try_new(0, 10, 2, vec![0.1; 8]).unwrap();
assert!(rule.attribute(&quiet, 0, 40).is_none());
}
}