Struct EmbeddingManager 

pub struct EmbeddingManager { /* private fields */ }

Implementations

impl EmbeddingManager

pub fn new(max_speakers: usize) -> Self

Examples found in repository

examples/infinite.rs (line 44)

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

    let embedding_model_path = "wespeaker_en_voxceleb_CAM++.onnx";
    let segmentation_model_path = "segmentation-3.0.onnx";

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

    let segments = pyannote_rs::get_segments(&samples, sample_rate, segmentation_model_path)?;

    for segment in segments {
        if let Ok(segment) = segment {
            if let Err(error) = process_segment(
                segment,
                &mut embedding_extractor,
                &mut embedding_manager,
                search_threshold,
            ) {
                eprintln!("Error processing segment: {:?}", error);
            }
        } else if let Err(error) = segment {
            eprintln!("Failed to process segment: {:?}", error);
        }
    }

    Ok(())
}

examples/max_speakers.rs (line 9)

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

    let mut extractor = EmbeddingExtractor::new("wespeaker_en_voxceleb_CAM++.onnx").unwrap();
    let mut manager = EmbeddingManager::new(6);

    let segments =
        pyannote_rs::get_segments(&samples, sample_rate, "segmentation-3.0.onnx").unwrap();

    for segment in segments {
        match segment {
            Ok(segment) => {
                if let Ok(embedding) = extractor.compute(&segment.samples) {
                    let speaker = if manager.get_all_speakers().len() == max_speakers {
                        manager
                            .get_best_speaker_match(embedding.collect())
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    } else {
                        manager
                            .search_speaker(embedding.collect(), 0.5)
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    };
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = {}",
                        segment.start, segment.end, speaker
                    );
                } else {
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = ?",
                        segment.start, segment.end
                    );
                }
            }
            Err(error) => eprintln!("Failed to process segment: {:?}", error),
        }
    }
}

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

Search or create speaker

Examples found in repository

examples/infinite.rs (line 22)

fn process_segment(
    segment: pyannote_rs::Segment,
    embedding_extractor: &mut EmbeddingExtractor,
    embedding_manager: &mut EmbeddingManager,
    search_threshold: f32,
) -> Result<(), eyre::Report> {
    let embedding_result: Vec<f32> = embedding_extractor
        .compute(&segment.samples)
        .unwrap()
        .collect();

    let speaker = embedding_manager
        .search_speaker(embedding_result.clone(), search_threshold)
        .ok_or_else(|| embedding_manager.search_speaker(embedding_result, 0.0)) // Ensure always to return speaker
        .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 25)

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

    let mut extractor = EmbeddingExtractor::new("wespeaker_en_voxceleb_CAM++.onnx").unwrap();
    let mut manager = EmbeddingManager::new(6);

    let segments =
        pyannote_rs::get_segments(&samples, sample_rate, "segmentation-3.0.onnx").unwrap();

    for segment in segments {
        match segment {
            Ok(segment) => {
                if let Ok(embedding) = extractor.compute(&segment.samples) {
                    let speaker = if manager.get_all_speakers().len() == max_speakers {
                        manager
                            .get_best_speaker_match(embedding.collect())
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    } else {
                        manager
                            .search_speaker(embedding.collect(), 0.5)
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    };
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = {}",
                        segment.start, segment.end, speaker
                    );
                } else {
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = ?",
                        segment.start, segment.end
                    );
                }
            }
            Err(error) => eprintln!("Failed to process segment: {:?}", error),
        }
    }
}

pub fn get_best_speaker_match(&mut self, embedding: Vec<f32>) -> Result<usize>

Examples found in repository

examples/max_speakers.rs (line 20)

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

    let mut extractor = EmbeddingExtractor::new("wespeaker_en_voxceleb_CAM++.onnx").unwrap();
    let mut manager = EmbeddingManager::new(6);

    let segments =
        pyannote_rs::get_segments(&samples, sample_rate, "segmentation-3.0.onnx").unwrap();

    for segment in segments {
        match segment {
            Ok(segment) => {
                if let Ok(embedding) = extractor.compute(&segment.samples) {
                    let speaker = if manager.get_all_speakers().len() == max_speakers {
                        manager
                            .get_best_speaker_match(embedding.collect())
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    } else {
                        manager
                            .search_speaker(embedding.collect(), 0.5)
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    };
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = {}",
                        segment.start, segment.end, speaker
                    );
                } else {
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = ?",
                        segment.start, segment.end
                    );
                }
            }
            Err(error) => eprintln!("Failed to process segment: {:?}", error),
        }
    }
}

pub fn get_all_speakers(&self) -> &HashMap<usize, Array1<f32>>

Examples found in repository

examples/max_speakers.rs (line 18)

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

    let mut extractor = EmbeddingExtractor::new("wespeaker_en_voxceleb_CAM++.onnx").unwrap();
    let mut manager = EmbeddingManager::new(6);

    let segments =
        pyannote_rs::get_segments(&samples, sample_rate, "segmentation-3.0.onnx").unwrap();

    for segment in segments {
        match segment {
            Ok(segment) => {
                if let Ok(embedding) = extractor.compute(&segment.samples) {
                    let speaker = if manager.get_all_speakers().len() == max_speakers {
                        manager
                            .get_best_speaker_match(embedding.collect())
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    } else {
                        manager
                            .search_speaker(embedding.collect(), 0.5)
                            .map(|s| s.to_string())
                            .unwrap_or("?".into())
                    };
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = {}",
                        segment.start, segment.end, speaker
                    );
                } else {
                    println!(
                        "start = {:.2}, end = {:.2}, speaker = ?",
                        segment.start, segment.end
                    );
                }
            }
            Err(error) => eprintln!("Failed to process segment: {:?}", error),
        }
    }
}

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.