Struct EmbeddingManager 

pub struct EmbeddingManager { /* private fields */ }

Implementations

impl EmbeddingManager

pub fn new(max_speakers: usize) -> Self

Examples found in repository

examples/max_speakers.rs (line 10)

fn main() -> Result<()> {
    let audio_path = std::env::args().nth(1).expect("Please specify audio file");
    let (samples, sample_rate) = read_wav(&audio_path)?;
    let max_speakers = 6;

    let extractor = EmbeddingExtractor::new("src/nn/speaker_identification/model.bpk")?;
    let mut manager = EmbeddingManager::new(max_speakers);
    let segmenter = Segmenter::new("src/nn/segmentation/model.bpk")?;

    for segment in segmenter.iter_segments(&samples, sample_rate)? {
        let segment = segment?;
        let embedding = extractor.extract(&segment.samples, sample_rate)?;

        let speaker = if manager.is_full() {
            manager.best_match(&embedding)
        } else {
            manager.upsert(&embedding, 0.5)
        }
        .map(|s| s.to_string())
        .unwrap_or_else(|| "?".into());

        println!(
            "start = {:.2}, end = {:.2}, speaker = {}",
            segment.start, segment.end, speaker
        );
    }

    Ok(())
}

examples/infinite.rs (line 40)

fn main() -> Result<()> {
    let audio_path = std::env::args().nth(1).expect("Please specify audio file");
    let search_threshold = 0.5;

    let embedding_model_path = "src/nn/speaker_identification/model.bpk";
    let segmentation_model_path = "src/nn/segmentation/model.bpk";

    let (samples, sample_rate) = pyannote_rs::read_wav(&audio_path)?;
    let embedding_extractor = EmbeddingExtractor::new(embedding_model_path)?;
    let mut embedding_manager = EmbeddingManager::new(usize::MAX);
    let segmenter = Segmenter::new(segmentation_model_path)?;

    for segment in segmenter.iter_segments(&samples, sample_rate)? {
        match segment {
            Ok(segment) => {
                if let Err(error) = process_segment(
                    segment,
                    &embedding_extractor,
                    &mut embedding_manager,
                    search_threshold,
                    sample_rate,
                ) {
                    eprintln!("Error processing segment: {:?}", error);
                }
            }
            Err(error) => eprintln!("Failed to process segment: {:?}", error),
        }
    }

    Ok(())
}

pub fn upsert(&mut self, embedding: &Embedding, threshold: f32) -> Option<usize>

Try to match a speaker; if none is found above threshold, register a new speaker as long as capacity allows.

Examples found in repository

examples/infinite.rs (line 18)

fn process_segment(
    segment: pyannote_rs::Segment,
    embedding_extractor: &EmbeddingExtractor,
    embedding_manager: &mut EmbeddingManager,
    search_threshold: f32,
    sample_rate: u32,
) -> Result<()> {
    let embedding = embedding_extractor.extract(&segment.samples, sample_rate)?;

    let speaker = embedding_manager
        .upsert(&embedding, search_threshold)
        .or_else(|| embedding_manager.best_match(&embedding))
        .map(|r| r.to_string())
        .unwrap_or("?".into());

    println!(
        "start = {:.2}, end = {:.2}, speaker = {}",
        segment.start, segment.end, speaker
    );

    Ok(())
}

examples/max_speakers.rs (line 20)

fn main() -> Result<()> {
    let audio_path = std::env::args().nth(1).expect("Please specify audio file");
    let (samples, sample_rate) = read_wav(&audio_path)?;
    let max_speakers = 6;

    let extractor = EmbeddingExtractor::new("src/nn/speaker_identification/model.bpk")?;
    let mut manager = EmbeddingManager::new(max_speakers);
    let segmenter = Segmenter::new("src/nn/segmentation/model.bpk")?;

    for segment in segmenter.iter_segments(&samples, sample_rate)? {
        let segment = segment?;
        let embedding = extractor.extract(&segment.samples, sample_rate)?;

        let speaker = if manager.is_full() {
            manager.best_match(&embedding)
        } else {
            manager.upsert(&embedding, 0.5)
        }
        .map(|s| s.to_string())
        .unwrap_or_else(|| "?".into());

        println!(
            "start = {:.2}, end = {:.2}, speaker = {}",
            segment.start, segment.end, speaker
        );
    }

    Ok(())
}

pub fn best_match(&self, embedding: &Embedding) -> Option<usize>

Examples found in repository

examples/infinite.rs (line 19)

fn process_segment(
    segment: pyannote_rs::Segment,
    embedding_extractor: &EmbeddingExtractor,
    embedding_manager: &mut EmbeddingManager,
    search_threshold: f32,
    sample_rate: u32,
) -> Result<()> {
    let embedding = embedding_extractor.extract(&segment.samples, sample_rate)?;

    let speaker = embedding_manager
        .upsert(&embedding, search_threshold)
        .or_else(|| embedding_manager.best_match(&embedding))
        .map(|r| r.to_string())
        .unwrap_or("?".into());

    println!(
        "start = {:.2}, end = {:.2}, speaker = {}",
        segment.start, segment.end, speaker
    );

    Ok(())
}

examples/max_speakers.rs (line 18)

fn main() -> Result<()> {
    let audio_path = std::env::args().nth(1).expect("Please specify audio file");
    let (samples, sample_rate) = read_wav(&audio_path)?;
    let max_speakers = 6;

    let extractor = EmbeddingExtractor::new("src/nn/speaker_identification/model.bpk")?;
    let mut manager = EmbeddingManager::new(max_speakers);
    let segmenter = Segmenter::new("src/nn/segmentation/model.bpk")?;

    for segment in segmenter.iter_segments(&samples, sample_rate)? {
        let segment = segment?;
        let embedding = extractor.extract(&segment.samples, sample_rate)?;

        let speaker = if manager.is_full() {
            manager.best_match(&embedding)
        } else {
            manager.upsert(&embedding, 0.5)
        }
        .map(|s| s.to_string())
        .unwrap_or_else(|| "?".into());

        println!(
            "start = {:.2}, end = {:.2}, speaker = {}",
            segment.start, segment.end, speaker
        );
    }

    Ok(())
}

pub fn speaker_count(&self) -> usize

pub fn is_full(&self) -> bool

Examples found in repository

examples/max_speakers.rs (line 17)

fn main() -> Result<()> {
    let audio_path = std::env::args().nth(1).expect("Please specify audio file");
    let (samples, sample_rate) = read_wav(&audio_path)?;
    let max_speakers = 6;

    let extractor = EmbeddingExtractor::new("src/nn/speaker_identification/model.bpk")?;
    let mut manager = EmbeddingManager::new(max_speakers);
    let segmenter = Segmenter::new("src/nn/segmentation/model.bpk")?;

    for segment in segmenter.iter_segments(&samples, sample_rate)? {
        let segment = segment?;
        let embedding = extractor.extract(&segment.samples, sample_rate)?;

        let speaker = if manager.is_full() {
            manager.best_match(&embedding)
        } else {
            manager.upsert(&embedding, 0.5)
        }
        .map(|s| s.to_string())
        .unwrap_or_else(|| "?".into());

        println!(
            "start = {:.2}, end = {:.2}, speaker = {}",
            segment.start, segment.end, speaker
        );
    }

    Ok(())
}

pub fn speakers(&self) -> &HashMap<usize, Embedding>

Trait Implementations

impl Clone for EmbeddingManager

fn clone(&self) -> EmbeddingManager

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EmbeddingManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.