add script for speaker diarization demo

README.md

@@ -1,13 +1,12 @@
 ---
-title: Speaker Diarization
-emoji: 😻
-colorFrom: purple
-colorTo: yellow
+title: Diarization
+emoji: 🐠
+colorFrom: red
+colorTo: green
 sdk: streamlit
 sdk_version: 1.10.0
 app_file: app.py
 pinned: false
-license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,167 @@
+"""
+General streamlit diarization application
+"""
+import os
+import shutil
+from io import BytesIO
+from typing import Dict, Union
+from pathlib import Path
+
+import librosa
+import librosa.display
+import matplotlib.figure
+import numpy as np
+import streamlit as st
+import streamlit.uploaded_file_manager
+from PIL import Image
+from pydub import AudioSegment
+from matplotlib import pyplot as plt
+
+import configs
+from utils import audio_utils, text_utils, general_utils, streamlit_utils
+from diarizers import pyannote_diarizer, nemo_diarizer
+
+plt.rcParams["figure.figsize"] = (10, 5)
+
+
+def plot_audio_diarization(diarization_figure: Union[plt.gcf, np.array], diarization_name: str,
+                           audio_data: np.array,
+                           sampling_frequency: int):
+    """
+    Function that plots the audio along with the different applied diarization techniques
+    Args:
+        diarization_figure (plt.gcf): the diarization figure to plot
+        diarization_name (str): the name of the diarization technique
+        audio_data (np.array): the audio numpy array
+        sampling_frequency (int): the audio sampling frequency
+    """
+    col1, col2 = st.columns([3, 5])
+    with col1:
+        st.markdown(
+            f"<h4 style='text-align: center; color: black;'>Original</h5>",
+            unsafe_allow_html=True,
+        )
+        st.markdown("<br></br>", unsafe_allow_html=True)
+
+        st.audio(audio_utils.create_st_audio_virtualfile(audio_data, sampling_frequency))
+    with col2:
+        st.markdown(
+            f"<h4 style='text-align: center; color: black;'>{diarization_name}</h5>",
+            unsafe_allow_html=True,
+        )
+
+        if type(diarization_figure) == matplotlib.figure.Figure:
+            buf = BytesIO()
+            diarization_figure.savefig(buf, format="png")
+            st.image(buf)
+        else:
+            st.image(diarization_figure)
+    st.markdown("---")
+
+
+def execute_diarization(file_uploader: st.uploaded_file_manager.UploadedFile, selected_option: any,
+                        sample_option_dict: Dict[str, str],
+                        diarization_checkbox_dict: Dict[str, bool],
+                        session_id: str):
+    """
+    Function that exectutes the diarization based on the specified files and pipelines
+    Args:
+        file_uploader (st.uploaded_file_manager.UploadedFile): the uploaded streamlit audio file
+        selected_option (any): the selected option of samples
+        Dict[str, str]: a dictionary where the name is the file name (without extension to be listed
+        as an option for the user) and the value is the original file name
+        diarization_checkbox_dict (Dict[str, bool]): dictionary where the key is the Diarization
+        technique name and the value is a boolean indicating whether to apply that technique
+        session_id (str): unique id of the user session
+    """
+    user_folder = os.path.join(configs.UPLOADED_AUDIO_SAMPLES_DIR, session_id)
+    Path(user_folder).mkdir(parents=True, exist_ok=True)
+
+    if file_uploader is not None:
+        file_name = file_uploader.name
+        file_path = os.path.join(user_folder, file_name)
+        audio = AudioSegment.from_wav(file_uploader).set_channels(1)
+        # slice first 30 seconds (slicing is done by ms)
+        audio = audio[0:1000 * 30]
+        audio.export(file_path, format='wav')
+    else:
+        file_name = sample_option_dict[selected_option]
+        file_path = os.path.join(configs.AUDIO_SAMPLES_DIR, file_name)
+
+    audio_data, sampling_frequency = librosa.load(file_path)
+
+    nb_pipelines_to_run = sum(pipeline_bool for pipeline_bool in diarization_checkbox_dict.values())
+    pipeline_count = 0
+    for diarization_idx, (diarization_name, diarization_bool) in \
+            enumerate(diarization_checkbox_dict.items()):
+
+        if diarization_bool:
+            pipeline_count += 1
+            if diarization_name == 'PyAnnote':
+                diarizer = pyannote_diarizer.PyannoteDiarizer(file_path)
+            elif diarization_name == 'NeMo':
+                diarizer = nemo_diarizer.NemoDiarizer(file_path, user_folder)
+            else:
+                raise NotImplementedError('Framework not recognized')
+
+            if file_uploader is not None:
+                with st.spinner(
+                        f"Executing {pipeline_count}/{nb_pipelines_to_run} diarization pipelines "
+                        f"({diarization_name}). This might take 1-2 minutes..."):
+                    diarizer_figure = diarizer.get_diarization_figure()
+            else:
+                diarizer_figure = Image.open(f"{configs.PRECOMPUTED_DIARIZATION_FIGURE}/"
+                                             f"{file_name.rsplit('.')[0]}_{diarization_name}.png")
+
+            plot_audio_diarization(diarizer_figure, diarization_name, audio_data,
+                                   sampling_frequency)
+
+    shutil.rmtree(user_folder)
+
+
+def main():
+    # 1) Write input text
+    text_utils.intro_container()
+    diarization_container = st.container()
+
+    # 2)Create the diarization container
+    diarization_container.markdown("---")
+
+    # 2.1) Diarization method
+    text_utils.demo_container(diarization_container)
+    diarization_container.markdown("Choose the Diarization method here:")
+
+    diarization_checkbox_dict = {}
+    for diarization_method in configs.DIARIZATION_METHODS:
+        diarization_checkbox_dict[diarization_method] = diarization_container.checkbox(
+            diarization_method)
+
+    # 2.2) Diarization upload/sample select
+    diarization_container.markdown("(Optional) Upload an audio file here:")
+    file_uploader = diarization_container.file_uploader(
+        label="", type=[".wav", ".wave"]
+    )
+
+    sample_option_dict = general_utils.get_dict_of_audio_samples(configs.AUDIO_SAMPLES_DIR)
+    diarization_container.markdown("Or select a sample file here:")
+    selected_option = diarization_container.selectbox(
+        label="", options=list(sample_option_dict.keys())
+    )
+    diarization_container.markdown("---")
+
+    ## 2.3) Apply specified diarization pipeline
+    if diarization_container.button("Apply"):
+        session_id = streamlit_utils.get_session()
+        execute_diarization(
+            file_uploader=file_uploader,
+            selected_option=selected_option,
+            sample_option_dict=sample_option_dict,
+            diarization_checkbox_dict=diarization_checkbox_dict,
+            session_id=session_id
+        )
+    text_utils.conlusion_container()
+
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide", page_title="Audio diarization visualization")
+    main()

configs.py

@@ -0,0 +1,5 @@
+"""General configs"""
+DIARIZATION_METHODS = ['PyAnnote', 'NeMo']
+AUDIO_SAMPLES_DIR = 'samples'
+UPLOADED_AUDIO_SAMPLES_DIR = 'uploaded_samples'
+PRECOMPUTED_DIARIZATION_FIGURE = 'computed_diarization_plots'

diarizers/diarizer.py

@@ -0,0 +1,21 @@
+"""
+Abstract class for diarization
+"""
+
+import matplotlib.pyplot as plt
+
+from abc import ABC, abstractmethod
+
+
+class Diarizer(ABC):
+    """
+    Diarizer base class
+    """
+
+    @abstractmethod
+    def get_diarization_figure(self) -> plt.gcf:
+        """
+        Function that returns the audio plot with diarization segmentations
+        Returns:
+            plt.gcf: the diarization plot
+        """

diarizers/input_manifest.json

@@ -0,0 +1 @@
+{"audio_filepath": "uploaded_samples/0217b861_28cd_4326_a5ea_ffa48f26d5bb/ES2004a.Mix-Headset_cut_2.wav", "offset": 0, "duration": null, "label": "infer", "text": "-", "num_speakers": null, "rttm_filepath": null, "uem_filepath": null}

diarizers/nemo_diarizer.py

@@ -0,0 +1,114 @@
+"""
+Nemo diarizer
+"""
+import os
+import json
+
+import wget
+import matplotlib.pyplot as plt
+from omegaconf import OmegaConf
+from nemo.collections.asr.models import ClusteringDiarizer
+from nemo.collections.asr.parts.utils.speaker_utils import rttm_to_labels, labels_to_pyannote_object
+from pyannote.core import notebook
+
+from diarizers.diarizer import Diarizer
+
+
+class NemoDiarizer(Diarizer):
+    """Class for Nemo Diarizer"""
+
+    def __init__(self, audio_path: str, data_dir: str):
+        """
+        Nemo diarizer class
+        Args:
+            audio_path (str): the path to the audio file
+        """
+        self.audio_path = audio_path
+        self.data_dir = data_dir
+        self.diarization = None
+        self.manifest_dir = os.path.join(self.data_dir, 'input_manifest.json')
+        self.model_config = os.path.join(self.data_dir, 'offline_diarization.yaml')
+        if not os.path.exists(self.model_config):
+            config_url = "https://raw.githubusercontent.com/NVIDIA/NeMo/main/examples/" \
+                         "speaker_tasks/diarization/conf/offline_diarization.yaml"
+            self.model_config = wget.download(config_url, self.data_dir)
+        self.config = OmegaConf.load(self.model_config)
+
+    def _create_manifest_file(self):
+        """
+        Function that creates inference manifest file
+        """
+        meta = {
+            'audio_filepath': self.audio_path,
+            'offset': 0,
+            'duration': None,
+            'label': 'infer',
+            'text': '-',
+            'num_speakers': None,
+            'rttm_filepath': None,
+            'uem_filepath': None
+        }
+        with open(self.manifest_dir, 'w') as fp:
+            json.dump(meta, fp)
+            fp.write('\n')
+
+    def _apply_config(self, pretrained_speaker_model: str = 'ecapa_tdnn'):
+        """
+        Function that edits the inference configuration file
+        Args:
+            pretrained_speaker_model (str): the pre-trained embedding model options are
+            ('escapa_tdnn', vad_telephony_marblenet, titanet_large, ecapa_tdnn)
+            https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/
+            speaker_diarization/results.html
+        """
+
+        pretrained_vad = 'vad_marblenet'
+
+        output_dir = os.path.join(self.data_dir, 'outputs')
+        self.config.diarizer.manifest_filepath = self.manifest_dir
+        self.config.diarizer.out_dir = output_dir
+        self.config.diarizer.ignore_overlap = False
+
+        self.config.diarizer.speaker_embeddings.model_path = pretrained_speaker_model
+        self.config.diarizer.speaker_embeddings.parameters.window_length_in_sec = 1.5
+        self.config.diarizer.speaker_embeddings.parameters.shift_length_in_sec = 0.75
+        self.config.diarizer.oracle_vad = False
+        self.config.diarizer.clustering.parameters.oracle_num_speakers = False
+
+        # Here we use our inhouse pretrained NeMo VAD
+        self.config.diarizer.vad.model_path = pretrained_vad
+        self.config.diarizer.vad.window_length_in_sec = 0.15
+        self.config.diarizer.vad.shift_length_in_sec = 0.01
+        self.config.diarizer.vad.parameters.onset = 0.8
+        self.config.diarizer.vad.parameters.offset = 0.6
+        self.config.diarizer.vad.parameters.min_duration_on = 0.1
+        self.config.diarizer.vad.parameters.min_duration_off = 0.4
+
+    def diarize_audio(self, pretrained_speaker_model: str = 'ecapa_tdnn'):
+        """
+        function that diarizes the audio
+        Args:
+            pretrained_speaker_model (str): the pre-trained embedding model options are
+            ('escapa_tdnn', vad_telephony_marblenet, titanet_large, ecapa_tdnn)
+            https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/
+            speaker_diarization/results.html
+        """
+        self._create_manifest_file()
+        self._apply_config(pretrained_speaker_model)
+        sd_model = ClusteringDiarizer(cfg=self.config)
+        sd_model.diarize()
+        audio_file_name_without_extension = os.path.basename(self.audio_path).rsplit('.', 1)[0]
+        output_diarization_pred = f'{self.data_dir}/outputs/pred_rttms/' \
+                                  f'{audio_file_name_without_extension}.rttm'
+        pred_labels = rttm_to_labels(output_diarization_pred)
+        self.diarization = labels_to_pyannote_object(pred_labels)
+
+    def get_diarization_figure(self) -> plt.gcf:
+        """
+        Function that return the diarization figure
+        """
+        if not self.diarization:
+            self.diarize_audio()
+        figure, ax = plt.subplots()
+        notebook.plot_annotation(self.diarization, ax=ax, time=True, legend=True)
+        return plt.gcf()

diarizers/pyannote_diarizer.py

@@ -0,0 +1,35 @@
+"""
+pyannote diarizer
+"""
+
+import matplotlib.pyplot as plt
+
+from pyannote.audio import Pipeline
+from pyannote.core import notebook
+from diarizers.diarizer import Diarizer
+
+
+class PyannoteDiarizer(Diarizer):
+    def __init__(self, audio_path: str):
+        """
+        Pyannote diarizer class
+        Note: pyannote does not currently support defining the number of speakers, this
+        functionality might be supported later in the future
+        Args:
+            audio_path (str): the path to the audio file
+        Params:
+            diarization (Annotations): the output of the diarization algorithm
+        """
+        self.audio_path = audio_path
+        self.diarization = None
+
+    def diarize_audio(self):
+        pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization")
+        self.diarization = pipeline({'audio': self.audio_path})
+
+    def get_diarization_figure(self) -> plt.gcf:
+        if not self.diarization:
+            self.diarize_audio()
+        figure, ax = plt.subplots()
+        notebook.plot_annotation(self.diarization, ax=ax, time=True, legend=True)
+        return plt.gcf()

manifest_vad_input.json

@@ -0,0 +1 @@
+{"audio_filepath": "uploaded_samples/6f1f8cbc_f8bb_4a6a_9ce5_8c182df3e886/ES2004a.Mix-Headset_cut_2.wav", "duration": 30.0, "label": "infer", "text": "_", "offset": 0}

packages.txt

@@ -0,0 +1,3 @@
+libsndfile1
+ffmpeg
+sox

requirements.txt

@@ -0,0 +1,15 @@
+librosa==0.9.1
+Pillow==9.1.1
+numpy==1.22
+streamlit==1.10.0
+matplotlib==3.5.2
+scipy==1.8.1
+audiomentations==0.25.1
+pydub==0.25.1
+https://github.com/pyannote/pyannote-audio/archive/develop.zip
+speechbrain==0.5.11
+wget==3.2
+unidecode==1.3.4
+huggingface_hub==0.7
+torchaudio -f https://download.pytorch.org/whl/torch_stable.html
+git+https://github.com/NVIDIA/NeMo.git@main#egg=nemo_toolkit[asr]

utils/audio_utils.py

@@ -0,0 +1,46 @@
+"""General helper functions for audio processing"""
+
+import io
+
+import streamlit as st
+import streamlit.uploaded_file_manager
+import numpy as np
+import pydub
+from scipy.io import wavfile
+
+
+def create_st_audio_virtualfile(audio_data: np.array, sample_rate: int) -> io.BytesIO:
+    """
+    Function that creates the audi virtual file needed to run the audio player
+    Args:
+        audio_data (np.array): the audio data array
+        sample_rate (int): the sampling frequency fo the audio
+    Returns:
+        io.Bytesio: the audio virtual file stored in temporary memory
+    """
+    virtual_audio_file = io.BytesIO()
+    wavfile.write(virtual_audio_file, rate=sample_rate, data=audio_data)
+
+    return virtual_audio_file
+
+
+def parse_uploaded_audio_file(uploaded_file: st.uploaded_file_manager.UploadedFile):
+    """
+    Function that parses the uploaded file into it's a numpy array representation and sampling
+    frequency
+    Args:
+        uploaded_file (st.uploaded_file_manager.UploadedFile): the uploaded streamlit audio file
+    """
+    audio_data = pydub.AudioSegment.from_file(
+        file=uploaded_file, format=uploaded_file.name.split(".")[-1]
+    )
+
+    channel_sounds = audio_data.split_to_mono()
+    samples = [channel.get_array_of_samples() for channel in channel_sounds]
+
+    fp_arr = np.array(samples).T.astype(np.float32)
+    fp_arr /= np.iinfo(samples[0].typecode).max
+
+    return fp_arr[:, 0], audio_data.frame_rate
+
+

utils/general_utils.py

@@ -0,0 +1,23 @@
+"""
+General utility functions
+"""
+import os
+from typing import List, Dict
+
+
+def get_dict_of_audio_samples(audio_sample_path: str) -> Dict[str, str]:
+    """
+    Function that returns the list of available audio samples
+    Args:
+        audio_sample_path (str): The path to the directory with the audio samples
+    Returns:
+        Dict[str, str]: a dictionary where the name is the file name (without extension to be listed
+        as an option for the user) and the value is the original file name
+    """
+    audio_sample_dict = {}
+
+    for file in os.listdir(audio_sample_path):
+        file_option = os.path.basename(file).rsplit('.')[0]
+        audio_sample_dict[file_option] = file
+
+    return audio_sample_dict

utils/streamlit_utils.py

@@ -0,0 +1,11 @@
+from streamlit.scriptrunner import get_script_run_ctx as get_report_ctx
+
+
+def get_session() -> str:
+    """
+    Function that returns a unique identifier per user session
+    """
+
+    session_id = get_report_ctx().session_id.replace('-', '_')
+
+    return session_id

utils/text_utils.py

@@ -0,0 +1,282 @@
+"""
+Utils for generating text in streamlit
+"""
+import librosa
+import streamlit as st
+
+from PIL import Image
+
+from utils import audio_utils
+
+
+def intro_container():
+    container = st.container()
+    container.title(
+        'Who spoke when: Choosing the right speaker diarization tool')
+    container.markdown(
+        'With the increase in applications of automated ***speech recognition systems (ASR)***, '
+        'the ability to partition a speech audio stream with multiple speakers into individual'
+        ' segments associated with each individual has become a crucial part of understanding '
+        'speech data.')
+    container.markdown(
+        'In this blog post, we will take a look at different open source frameworks for'
+        'speaker diarization and provide you with a guide to pick the most suited '
+        'one for your use case.')
+
+    container.markdown(
+        "Before we get into the technical details, libraries and tools, let's first understand what"
+        " speaker diarization is and how it works!")
+    container.markdown("---")
+    container.header("🗣️ What is speaker diarization?️")
+
+    container.markdown('\n')
+    container.markdown(
+        'Speaker diarization aims to answer the question of ***"who spoke when"***. In short: diariziation algorithms '
+        'break down an audio stream of multiple speakers into segments corresponding to the individual speakers. '
+        'By combining the information that we get from diarization with ASR transcriptions, we can '
+        'transform the generated transcript into a format which is more readable and interpretable for humans '
+        'and that can be used for other downstream NLP tasks.')
+    col1_im1, col2_im1, col3_im1 = container.columns([2, 5, 2])
+
+    with col1_im1:
+        st.write(' ')
+
+    with col2_im1:
+        st.image(Image.open('docs/asr+diar.png'),
+                 caption='Workflow of combining the output of both ASR and speaker '
+                         'diarization on a speech signal to generate a speaker transcript.',
+                 use_column_width=True)
+
+    with col3_im1:
+        st.write(' ')
+
+    container.markdown(
+        "Let's illustrate this with an example. We have a recording of a casual phone conversation "
+        "between two people. You can see what the different transcriptions look like when we "
+        "transcribe the conversation with and without diarization.")
+
+    container.markdown('\n')
+
+    col1, col2, col3 = container.columns(3)
+    with col1:
+        st.subheader("🎧 Audio recording ")
+        st.markdown("<br></br>", unsafe_allow_html=True)
+        st.markdown("<br></br>", unsafe_allow_html=True)
+        st.markdown("<br></br>", unsafe_allow_html=True)
+        audio_data, sampling_frequency = librosa.load('blog_samples/4092.wav')
+        st.audio(audio_utils.create_st_audio_virtualfile(audio_data, sampling_frequency))
+
+    with col2:
+        st.subheader("❌ Without diarization")
+        st.text("I just got back from the gym. oh good.\n"
+                "uhuh. How's it going? oh pretty well. It was\n"
+                "really crowded today yeah. I kind of\n"
+                "assumed everyone would be at the shore.\n"
+                "uhhuh. I was wrong. Well it's the\n"
+                "middle of the week or whatever so. But\n"
+                "it's the fourth of July. mm. So. yeah.\n"
+                "People have to work tomorrow. Do you\n"
+                "have to work tomorrow? yeah. Did you\n"
+                "have off yesterday? Yes. oh that's good.\n"
+                "And I was paid too. oh. Is it paid today?\n"
+                "No. oh.\n")
+
+    with col3:
+        st.subheader('✅ With diarization')
+        st.text("A: I just got back from the gym.\n"
+                "B: oh good.\n"
+                "A: uhhuh.\n"
+                "B: How's it going?\n"
+                "A: oh pretty well.\n"
+                "A: It was really crowded today.\n"
+                "B: yeah.\n"
+                "A: I kind of assumed everyone would be at \n"
+                "the shore.\n"
+                "B: uhhuh.\n"
+                "A: I was wrong.\n"
+                "B: Well it's the middle of the week or\n"
+                " whatever so.\n"
+                "A: But it's the fourth of July.\n"
+                "B: mm.\n"
+                "A: So.\n"
+                "B: yeah.\n"
+                "B: People have to work tomorrow.\n"
+                "B: Do you have to work tomorrow?\n"
+                "A: yeah.\n"
+                "B: Did you have off yesterday?\n"
+                "A: Yes.\n"
+                "B: oh that's good.\n"
+                "A: And I was paid too.\n"
+                "B: oh.\n"
+                "B: Is it paid today?\n"
+                "A: No.\n"
+                "B: oh.\n")
+
+    container.markdown(
+        "By generating a **speaker-aware transcript**, we can more easily interpret the generated"
+        " conversation compared to a generated transcript without diarization. Much neater no? ✨")
+    container.caption(
+        "Alright, that's more interpretable for human readers, but what can I do with "
+        "those speaker-aware transcripts? 🤔")
+    container.markdown(
+        "Speaker-aware transcripts can be a powerful tool for analyzing speech data:")
+    container.markdown("""
+        * We can use the transcripts to analyze individual speaker's sentiment by using **sentiment analysis** on both audio and text transcripts.
+        * Another use case is telemedicine where we might identify the **<doctor>** and **<patient>** tags on the transcription to create an accurate transcript and attach it to the patient file or EHR system.
+        * Speaker Diarization can be used by hiring platforms to analyze phone and video recruitment calls. This allows them to split and categorize candidates depending on their response to certain questions without having to listen again to the recordings.
+        """)
+    container.markdown(
+        "Now that we've seen the importance of speaker diarization and some of its applications,"
+        " it's time to find out we can implement diarization algorithms.")
+
+    container.markdown("---")
+    container.header('📝 The workflow of a speaker diarization system')
+    container.markdown(
+        "Building robust and accurate speaker diarization is not as a trivial task."
+        " Real world audio data is messy and complex due to many factors, such"
+        " as having a noisy background, multiple speakers talking at the same time and "
+        "subtle differences between the speakers' voices in pitch and tone. Moreover, speaker diarization systems often suffer "
+        "from **domain mismatch** where a model on data from a specific domain works poorly when applied to another domain.")
+
+    container.markdown(
+        "All in all, tackling speaker diarization is no easy feat. Current speaker diarization systems can be divided into two categories: **Traditional systems** and **End-to-End systems**. Let's look at how they work:")
+    container.subheader('Traditional diarization systems')
+    container.markdown(
+        "Those consist of many independent submodules that are optimized individually, namely being:")
+    container.markdown("""
+            * **Speech detection**: The first step is to identify speech and remove non-speech signals with a voice activity detector (VAD) algorithm.
+            * **Speech segmentation**: The output of the VAD is then segmented into small segments consisting of a few seconds (usually 1-2 seconds). 
+            * **Speech embedder**: A neural network pre-trained on speaker recognition is used to derive a high-level representation of the speech segments. Those embeddings are vector representations that summarize the voice characteristics (a.k.a voice print).
+            * **Clustering**: After extracting segment embeddings, we need to cluster the speech embeddings with a clustering algorithm (for example K-Means or spectral clustering). The clustering produces our desired diarization results, which consists of identifying the number of unique speakers (derived from the number of unique clusters) and assigning a speaker label to each embedding (or speech segment). 
+             """)
+    col1_im1, col2_im1, col3_im1 = container.columns([2, 5, 2])
+
+    with col1_im1:
+        st.write(' ')
+
+    with col2_im1:
+        st.image(Image.open('docs/speech_embedding.png'),
+                 caption="Process of identifying speaker segments from speech activity embeddings.",
+
+                 use_column_width=True)
+
+    with col3_im1:
+        st.write(' ')
+
+    container.subheader('End-to-end diarization systems')
+    container.markdown(
+        "Here the individual submodules of the traditional speaker diarization system can be replaced by one neural network that is trained end-to-end on speaker diarization.")
+
+    container.markdown('**Advantages**')
+    container.markdown(
+        '➕ Direct optimization of the network towards maximizing the accuracy for the diarization task. This is in contrast with traditional systems where submodules are optimized individually but not as a whole.')
+    container.markdown(
+        '➕ Less need to come up with useful pre-processing and post-processing transformation on the input data.')
+    container.markdown(' **Disadvantages**')
+    container.markdown(
+        '➖ More effort needed for data collection and labelling. This is because this type of approach requires speaker-aware transcripts for training. This differs from traditional systems where only labels consisting of the speaker tag along with the audio timestamp are needed (without transcription efforts).')
+    container.markdown('➖ These systems have the tendency to overfit on the training data.')
+
+    container.markdown("---")
+    container.header('📚 Speaker diarization frameworks')
+    container.markdown(
+        "As you can see, there are advantages and disadvantages to both traditional and end-to-end diarization systems."
+        "Building a speaker diarization system also involves aggregating quite a few "
+        "building blocks and the implementation can seem daunting at first glance. Luckily, there exists a plethora "
+        "of libraries and packages that have all those steps implemented and are ready for you to use out of the box 🔥.")
+    container.markdown(
+        "I will focus on the most popular **open-source** speaker diarization libraries. Make sure to check out"
+        " [this link](https://wq2012.github.io/awesome-diarization/) for a more exhaustive list on different diarization libraries.")
+
+    container.markdown("### 1. [PyAnnote](https://github.com/pyannote/pyannote-audio)")
+    container.markdown(
+        "Arguably one of the most popular libraries out there for speaker diarization.\n"
+        "* Comes with a set of available pre-trained models for the VAD, embedder and segmentation model.\n"
+        "* The inference pipeline can identify multiple speakers speaking at the same time (multi-label diarization).\n"
+
+        "* It is not possible to define the number of speakers for the clustering algorithm. This could lead to an over-estimation or under-estimation of the number of speakers if they are known beforehand.")
+    "* Note that the pre-trained models are based on the [VoxCeleb datasets](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/) which consists of recording of celebrities extracted from YouTube. The audio quality of those recordings are crisp and clear, so you might need to retrain your model if you want to tackle other types of data like recorded phone calls.\n"
+
+    container.markdown("### 2. [NVIDIA NeMo](https://developer.nvidia.com/nvidia-nemo)")
+    container.markdown(
+        "The Nvidia NeMo toolkit has separate collections for Automatic Speech Recognition (ASR), Natural Language Processing (NLP), and Text-to-Speech (TTS) models.\n"
+        "* Diarization results can be combined easily with ASR outputs to generate speaker-aware transcripts.\n"
+        "* Possibility to define the number of speakers beforehand if they are known, resulting in a more accurate diarization output.\n"
+        "* The fact that the NeMo toolkit also includes NLP related frameworks makes it easy to integrate the diarization outcome with downstream NLP tasks.\n"
+        "* The models that the pre-trained networks were trained on were trained on [VoxCeleb datasets](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/) as well as the [Fisher](https://catalog.ldc.upenn.edu/LDC2004T19) and [SwitchBoard](https://catalog.ldc.upenn.edu/LDC97S62) dataset, which consists of telephone conversations in English. This makes it more suitable as a starting point for fine-tuning a model for call-center use cases compared to the pre-trained models used in PyAnnote. More information about the pre-trained models can be found [here](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/speaker_diarization/results.html).\n"
+    )
+    container.markdown("### 3. [Simple Diarizer](https://github.com/cvqluu/simple_diarizer)")
+    container.markdown(
+        "A simplified diarization pipeline that can be used for quick testing.\n"
+        "* Uses the same pre-trained models as PyAnnote.\n"
+        "* Unlike PyAnnote, this library does not include the option to fine tune the pre-trained models, making it less suitable for specialized use cases.\n"
+        "* Similarly to Nvidia NeMo, there's the option to define the number of speakers beforehand.\n")
+    container.markdown(
+        "### 4. [SpeechBrain](https://github.com/speechbrain/speechbrain)")
+    container.markdown(
+        "All-in-one conversational AI toolkit based on PyTorch.\n"
+        "* The SpeechBrain Ecosystem makes it easy to develop integrated speech solutions with systems such ASR, speaker identification, speech enhancement, speech separation and language identification.\n"
+        "* Large amount of pre-trained models for various tasks. Checkout their [HuggingFace page](https://huggingface.co/speechbrain) for more information.\n"
+        "* Contains [comprehensible tutorials](https://speechbrain.github.io/tutorial_basics.html) for various speech building blocks to easily get started.\n"
+        "* Diarization pipeline is still not fully implemented yet but this [might change in the future](https://github.com/speechbrain/speechbrain/issues/1208).")
+    container.markdown(
+        "### 5. [Kaldi](https://github.com/kaldi-asr/kaldi)")
+    container.markdown(
+        "Speech recognition toolkit that is mainly targeted towards researchers. It is written in C++ and used to train speech recognition models and decode audio from audio files.\n"
+        "* Relatively steep learning curve for beginners who don't have a lot of experience with speech recognition systems.\n"
+        "* Pre-trained model is based on the [CALLHOME](https://catalog.ldc.upenn.edu/LDC97S42) dataset which consists of telephone conversation between native English speakers in North America.\n"
+        "* Not suitable for a quick implementation of ASR/diarization systems. \n"
+        "* Benefits from large community support. However, mainly targeted towards researchers and less suitable for production ready-solutions.\n")
+
+    container.markdown(
+        "### 6. [UIS-RNN](https://github.com/google/uis-rnn)")
+    container.markdown(
+        "A fully supervised end-to-end diarization model developed by Google.\n"
+        "* No-pretrained model is available, so you need to train it from scratch on your custom transcribed data.\n"
+        "* Relatively easy to train if you have a large set of pre-labeled data.\n"
+        "* Both training and prediction require the usage of a GPU.\n")
+    container.markdown(
+        "Phew 😮‍💨, that's quite some different frameworks! To make it easier to pick the right one for your use case, I've created a simple flowchart that can get you started on picking a suitable library depending on your use case.")
+
+    col1_im2, col2_im2, col3_im2 = container.columns([4, 5, 4])
+
+    with col1_im2:
+        st.write(' ')
+
+    with col2_im2:
+        st.image(Image.open('docs/flow_chart_diarization_tree.png'),
+                 caption='Flowchart for choosing a framework suitable for your diarization use case.',
+                 use_column_width=True)
+
+    with col3_im2:
+        st.write(' ')
+
+
+def demo_container(diarization_container):
+    diarization_container.header('🤖 Demo')
+    diarization_container.markdown(
+        "Alright, you're probably very curious at this point to test out a few diarization techniques "
+        "yourself. Below is a demo where you can try a few of the libraries that are mentioned above. "
+        "You can try running multiple frameworks at the same time and compare their results by ticking multiple "
+        "frameworks and clicking **'Apply'**.")
+
+    diarization_container.caption(
+        "Disclaimer: Keep in mind that due to computational constraints, only the first 30 seconds will be used for diarization when uploading your own recordings. "
+        "For that reason, the diarization results may not be as accurate compared to diarization computed on longer recordings. This"
+        " is simply due to the fact that the diarization algorithms will have much less data to sample from in order to create meaningful clusters of embeddings for "
+        "each speaker. On the other hand, the diarization results from the provided samples are pre-computed on the whole recording (length of around ≈10min) and thus "
+        "have more accurate diarization results (only the first 30 seconds are shown).")
+
+
+def conlusion_container():
+    container = st.container()
+    container.title('💬 Conclusions')
+    container.markdown("In this blogpost we covered different aspects of speaker diarization.\n")
+    container.markdown(
+        "👉 First we explained what speaker diarization is and gave a few examples of its different areas of applications.\n")
+    container.markdown(
+        "👉 We discussed the two main types of systems for implementing diarization system with a solid (high-level) understanding of both **traditional systems** and **end-to-end** systems.")
+    container.markdown(
+        "👉 Then, we gave a comparison of different diarization frameworks and provided a guide for picking the best one for your use case.")
+    container.markdown(
+        "👉 Finally, we provided you with an example to quickly try out a few of the diarization libraries.")