change num_worker in nemo configs to enforce cpu usage

.gitignore

@@ -0,0 +1,10 @@
+target/
+dbt_modules/
+dbt_packages/
+logs/
+.venv/
+.vscode/
+*.pyc
+.idea/
+.DS_Store
+__pycache__/

app.py

@@ -119,49 +119,50 @@ def execute_diarization(file_uploader: st.uploaded_file_manager.UploadedFile, se
     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"]
+st.set_page_config(
+    page_title="📜 Audio diarization visualization 📜",
+    page_icon="",
+    layout="wide",
+    initial_sidebar_state="auto",
+    menu_items={
+        'Get help': None,
+        'Report a bug': None,
+        'About': None,
+    }
+)
+
+text_utils.intro_container()
+# 2.1) Diarization method
+text_utils.demo_container()
+st.markdown("Choose the Diarization method here:")
+
+diarization_checkbox_dict = {}
+for diarization_method in configs.DIARIZATION_METHODS:
+    diarization_checkbox_dict[diarization_method] = st.checkbox(
+        diarization_method)
+
+# 2.2) Diarization upload/sample select
+st.markdown("(Optional) Upload an audio file here:")
+file_uploader = st.file_uploader(
+    label="", type=[".wav", ".wave"]
+)
+
+sample_option_dict = general_utils.get_dict_of_audio_samples(configs.AUDIO_SAMPLES_DIR)
+st.markdown("Or select a sample file here:")
+selected_option = st.selectbox(
+    label="", options=list(sample_option_dict.keys())
+)
+st.markdown("---")
+
+## 2.3) Apply specified diarization pipeline
+if st.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
     )
 
-    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()
+text_utils.conlusion_container()

diarizers/nemo_diarizer.py

@@ -64,14 +64,16 @@ class NemoDiarizer(Diarizer):
 
         pretrained_vad = 'vad_marblenet'
 
+        self.config.num_workers = 0
         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.speaker_embeddings.parameters.window_length_in_sec = 0.5
+        self.config.diarizer.speaker_embeddings.parameters.shift_length_in_sec = 0.25
         self.config.diarizer.oracle_vad = False
         self.config.diarizer.clustering.parameters.oracle_num_speakers = False
 

utils/text_utils.py

@@ -10,33 +10,32 @@ from utils import audio_utils
 
 
 def intro_container():
-    container = st.container()
-    container.title(
+    st.title(
         'Who spoke when: Choosing the right speaker diarization tool')
-    container.markdown(
+    st.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(
+    st.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(
+    st.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?️")
+    st.markdown("---")
+    st.header("🗣️ What is speaker diarization?️")
 
-    container.markdown('\n')
-    container.markdown(
+    st.markdown('\n')
+    st.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])
+    col1_im1, col2_im1, col3_im1 = st.columns([2, 5, 2])
 
     with col1_im1:
         st.write(' ')
@@ -50,14 +49,14 @@ def intro_container():
     with col3_im1:
         st.write(' ')
 
-    container.markdown(
+    st.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')
+    st.markdown('\n')
 
-    col1, col2, col3 = container.columns(3)
+    col1, col2, col3 = st.columns(3)
     with col1:
         st.subheader("🎧 Audio recording ")
         st.markdown("<br></br>", unsafe_allow_html=True)
@@ -112,43 +111,43 @@ def intro_container():
                 "A: No.\n"
                 "B: oh.\n")
 
-    container.markdown(
+    st.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(
+    st.caption(
         "But what can I do with these speaker-aware transcripts? 🤔")
-    container.markdown(
+    st.markdown(
         "Speaker-aware transcripts can be a powerful tool for analyzing speech data:")
-    container.markdown("""
+    st.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(
+    st.markdown(
         "Now that we've seen the importance of speaker diarization and some of its applications,"
         " it's time to find out how we can implement diarization algorithms.")
 
-    container.markdown("---")
-    container.header('📝 The workflow of a speaker diarization system')
-    container.markdown(
+    st.markdown("---")
+    st.header('📝 The workflow of a speaker diarization system')
+    st.markdown(
         "Building robust and accurate speaker diarization is not 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(
+    st.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(
+    st.subheader('Traditional diarization systems')
+    st.markdown(
         "Those consist of many independent submodules that are optimized individually, namely being:")
-    container.markdown("""
+    st.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])
+    col1_im1, col2_im1, col3_im1 = st.columns([2, 5, 2])
 
     with col1_im1:
         st.write(' ')
@@ -162,102 +161,102 @@ def intro_container():
     with col3_im1:
         st.write(' ')
 
-    container.subheader('End-to-end diarization systems')
-    container.markdown(
+    st.subheader('End-to-end diarization systems')
+    st.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(
+    st.markdown('**Advantages**')
+    st.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(
+    st.markdown(
         '➕ Less need to come up with useful pre-processing and post-processing transformation on the input data.')
-    container.markdown(' **Disadvantages**')
-    container.markdown(
+    st.markdown(' **Disadvantages**')
+    st.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.')
+    st.markdown('➖ These systems have the tendency to overfit on the training data.')
 
-    container.markdown("---")
-    container.header('📚 Speaker diarization frameworks')
-    container.markdown(
+    st.markdown("---")
+    st.header('📚 Speaker diarization frameworks')
+    st.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(
+    st.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(
+    st.markdown("### 1. [pyannote](https://github.com/pyannote/pyannote-audio)")
+    st.markdown(
         "Arguably one of the most popular libraries out there for speaker diarization.\n")
-    container.markdown(
+    st.markdown(
         "👉 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(
+    st.markdown(
         "➕ Comes with a set of available pre-trained models for the VAD, embedder and segmentation model.\n")
-    container.markdown(
+    st.markdown(
         "➕ The inference pipeline can identify multiple speakers speaking at the same time (multi-label diarization).\n")
-    container.markdown(
+    st.markdown(
         "➖ 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.")
-    container.markdown("### 2. [NVIDIA NeMo](https://developer.nvidia.com/nvidia-nemo)")
-    container.markdown(
+    st.markdown("### 2. [NVIDIA NeMo](https://developer.nvidia.com/nvidia-nemo)")
+    st.markdown(
         "The Nvidia NeMo toolkit has separate collections for Automatic Speech Recognition (ASR), Natural Language Processing (NLP), and Text-to-Speech (TTS) models.\n")
-    container.markdown(
+    st.markdown(
         "👉 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(
+    st.markdown(
         "➕ Diarization results can be combined easily with ASR outputs to generate speaker-aware transcripts.\n")
-    container.markdown(
+    st.markdown(
         "➕ Possibility to define the number of speakers beforehand if they are known, resulting in a more accurate diarization output.\n")
-    container.markdown(
+    st.markdown(
         "➕ The fact that the NeMo toolkit also includes NLP related frameworks makes it easy to integrate the diarization outcome with downstream NLP tasks.\n")
-    container.markdown("### 3. [Simple Diarizer](https://github.com/cvqluu/simple_diarizer)")
-    container.markdown(
+    st.markdown("### 3. [Simple Diarizer](https://github.com/cvqluu/simple_diarizer)")
+    st.markdown(
         "A simplified diarization pipeline that can be used for quick testing.\n")
-    container.markdown(
+    st.markdown(
         "👉 Uses the same pre-trained models as pyannote.\n")
-    container.markdown(
+    st.markdown(
         "➕ Similarly to Nvidia NeMo, there's the option to define the number of speakers beforehand.\n")
-    container.markdown(
+    st.markdown(
         "➖ 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")
-    container.markdown(
+    st.markdown(
         "### 4. [SpeechBrain](https://github.com/speechbrain/speechbrain)")
-    container.markdown(
+    st.markdown(
         "All-in-one conversational AI toolkit based on PyTorch.\n")
-    container.markdown(
+    st.markdown(
         "➕ 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")
-    container.markdown(
+    st.markdown(
         "➕ Large amount of pre-trained models for various tasks. Checkout their [HuggingFace page](https://huggingface.co/speechbrain) for more information.\n")
-    container.markdown(
+    st.markdown(
         "➕ Contains [comprehensible tutorials](https://speechbrain.github.io/tutorial_basics.html) for various speech building blocks to easily get started.\n")
-    container.markdown(
+    st.markdown(
         "➖ Diarization pipeline is still not fully implemented yet but this [might change in the future](https://github.com/speechbrain/speechbrain/issues/1208).")
-    container.markdown(
+    st.markdown(
         "### 5. [Kaldi](https://github.com/kaldi-asr/kaldi)")
-    container.markdown(
+    st.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")
-    container.markdown(
+    st.markdown(
         "👉 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")
-    container.markdown(
+    st.markdown(
         "👉 Benefits from large community support. However, mainly targeted towards researchers and less suitable for production ready-solutions.\n")
-    container.markdown(
+    st.markdown(
         "➖  Relatively steep learning curve for beginners who don't have a lot of experience with speech recognition systems.\n")
-    container.markdown(
+    st.markdown(
         "➖  Not suitable for a quick implementation of ASR/diarization systems. \n")
 
-    container.markdown(
+    st.markdown(
         "### 6. [UIS-RNN](https://github.com/google/uis-rnn)")
-    container.markdown(
+    st.markdown(
         "A fully supervised end-to-end diarization model developed by Google.\n")
-    container.markdown(
+    st.markdown(
         "👉 Both training and prediction require the usage of a GPU.\n")
-    container.markdown(
+    st.markdown(
         "➖ No-pretrained model is available, so you need to train it from scratch on your custom transcribed data.\n")
-    container.markdown(
+    st.markdown(
         "➕ Relatively easy to train if you have a large set of pre-labeled data.\n")
-    container.markdown("\n")
-    container.markdown(
+    st.markdown("\n")
+    st.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])
+    col1_im2, col2_im2, col3_im2 = st.columns([4, 5, 4])
 
     with col1_im2:
         st.write(' ')
@@ -271,17 +270,17 @@ def intro_container():
         st.write(' ')
 
 
-def demo_container(diarization_container):
-    diarization_container.header('🤖 Demo')
-    diarization_container.markdown(
+def demo_container():
+    st.header('🤖 Demo')
+    st.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'**.\n")
-    diarization_container.markdown(
+    st.markdown(
         "**Note:** We are including **Nemo** and **pyannote** frameworks since we are operating on a single environment and a dependency conflict can occur when including other frameworks (most diarization frameworks rely "
         "on different and incompatible versions of the same shared packages).")
-    diarization_container.caption(
+    st.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 "
@@ -290,14 +289,13 @@ def demo_container(diarization_container):
 
 
 def conlusion_container():
-    container = st.container()
-    container.title('💬 Conclusions')
-    container.markdown("In this blogpost we covered different aspects of speaker diarization.\n")
-    container.markdown(
+    st.title('💬 Conclusions')
+    st.markdown("In this blogpost we covered different aspects of speaker diarization.\n")
+    st.markdown(
         "👉 First we explained what speaker diarization is and gave a few examples of its different areas of applications.\n")
-    container.markdown(
+    st.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(
+    st.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(
+    st.markdown(
         "👉 Finally, we provided you with an example to quickly try out a few of the diarization libraries.")