\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ " > to track results use the .show() or .logs() methods or click here to open in UI"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "> 2023-12-05 15:28:53,350 [info] Run execution finished: {'status': 'completed', 'name': 'speech-diarization-diarize'}\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Run the imported function with desired file/s and params\n",
+ "diarize_run = speech_diarization.run(\n",
+ " handler=\"diarize\",\n",
+ " inputs={\"data_path\": audio_files},\n",
+ " params={\n",
+ " \"device\": device,\n",
+ " \"speakers_labels\": speakers_labels,\n",
+ " \"separate_by_channels\": separate_by_channels,\n",
+ " },\n",
+ " returns=[\"speech-diarization: file\", \"diarize-errors: file\"],\n",
+ " local=True,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ede77975-8843-424f-b521-b9dd56ddad28",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "mlrun-base",
+ "language": "python",
+ "name": "conda-env-mlrun-base-py"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/functions/development/pyannote_audio/1.1.0/src/pyannote_audio.py b/functions/development/pyannote_audio/1.1.0/src/pyannote_audio.py
new file mode 100644
index 00000000..6271da6a
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/src/pyannote_audio.py
@@ -0,0 +1,376 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import heapq
+import logging
+import operator
+import os
+import pathlib
+from functools import reduce, wraps
+from typing import Any, Dict, List, Tuple, Union
+
+import pandas as pd
+import pyannote.audio
+import pyannote.core
+import torch
+import torchaudio
+from tqdm import tqdm
+
+# Get the global logger:
+_LOGGER = logging.getLogger()
+
+
+def _check_mlrun_and_open_mpi() -> Tuple["mlrun.MLClientCtx", "mpi4py.MPI.Intracomm"]:
+ is_mpi = False
+ try:
+ import mlrun
+
+ context = mlrun.get_or_create_ctx(name="mlrun")
+ is_mpi = context.labels.get("kind", "job") == "mpijob"
+
+ if is_mpi:
+ try:
+ from mpi4py import MPI
+
+ return context, MPI.COMM_WORLD
+ except ModuleNotFoundError as mpi4py_not_found:
+ context.logger.error(
+ "To distribute the function using MLRun's 'mpijob' you need to have `mpi4py` package in your "
+ "interpreter. Please run `pip install mpi4py` and make sure you have open-mpi."
+ )
+ raise mpi4py_not_found
+ else:
+ return context, None
+ except ModuleNotFoundError as module_not_found:
+ if is_mpi:
+ raise module_not_found
+ return None, None
+
+
+def open_mpi_handler(
+ worker_inputs: List[str], root_worker_inputs: Dict[str, Any] = None
+):
+ global _LOGGER
+
+ # Check for MLRun and OpenMPI availability:
+ context, comm = _check_mlrun_and_open_mpi()
+
+ # Check if MLRun is available, set the global logger to MLRun's:
+ if context:
+ _LOGGER = context.logger
+
+ def decorator(handler):
+ if comm is None or comm.Get_size() == 1:
+ return handler
+
+ @wraps(handler)
+ def wrapper(**kwargs):
+ # Get the open mpi environment properties:
+ size = comm.Get_size()
+ rank = comm.Get_rank()
+
+ # Give the correct chunk of the workers inputs:
+ for worker_input in worker_inputs:
+ input_argument = kwargs[worker_input]
+ if input_argument is None:
+ continue
+ if isinstance(input_argument, str):
+ input_argument = _get_audio_files(
+ data_path=pathlib.Path(input_argument).absolute()
+ )
+ if len(input_argument) < size:
+ raise ValueError(
+ f"Cannot split the input '{worker_input}' of length {len(input_argument)} to {size} workers. "
+ f"Please reduce the amount of workers for this input."
+ )
+ even_chunk_size = len(input_argument) // size
+ chunk_start = rank * even_chunk_size
+ chunk_end = (
+ (rank + 1) * even_chunk_size
+ if rank + 1 < size
+ else len(input_argument)
+ )
+ context.logger.info(
+ f"Rank #{rank}: Processing input chunk of '{worker_input}' "
+ f"from index {chunk_start} to {chunk_end}."
+ )
+ if isinstance(input_argument, list):
+ input_argument = input_argument[chunk_start:chunk_end]
+ elif isinstance(input_argument, pd.DataFrame):
+ input_argument = input_argument.iloc[chunk_start:chunk_end:, :]
+ kwargs[worker_input] = input_argument
+
+ # Set the root worker only arguments:
+ if rank == 0 and root_worker_inputs:
+ kwargs.update(root_worker_inputs)
+
+ # Run the worker:
+ output = handler(**kwargs)
+
+ # Send the output to the root rank (rank #0):
+ output = comm.gather(output, root=0)
+ if rank == 0:
+ # Join the outputs:
+ context.logger.info("Collecting data from workers to root worker.")
+ diarization_dictionary = reduce(
+ operator.ior, [dia for dia, _ in output], {}
+ )
+ errors_dictionary = reduce(operator.ior, [err for _, err in output], {})
+ return diarization_dictionary, errors_dictionary
+ return None
+
+ return wrapper
+
+ return decorator
+
+
+@open_mpi_handler(worker_inputs=["data_path"], root_worker_inputs={"verbose": True})
+def diarize(
+ data_path: Union[str, List[str]],
+ model_name: str = "pyannote/speaker-diarization-3.0",
+ access_token: str = None,
+ device: str = None,
+ speakers_labels: List[str] = None,
+ speaker_prefix: str = "speaker_",
+ separate_by_channels: bool = False,
+ minimum_speakers: int = None,
+ maximum_speakers: int = None,
+ verbose: bool = False,
+) -> Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]:
+ """
+ Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).
+ The end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ To use the `pyannote.audio` models you must pass a Huggingface token and get access to the required models. The
+ token can be passed in one of the following options:
+
+ * Use the parameter `access_token`.
+ * Set an environment variable named "HUGGING_FACE_HUB_TOKEN".
+ * If using MLRun, you can pass it as a secret named "HUGGING_FACE_HUB_TOKEN".
+
+ To get access to the models on Huggingface, visit their page. For example, to use the default diarization model set
+ in this function ("pyannote/speaker-diarization-3.0"), you need access for these two models:
+
+ * https://huggingface.co/pyannote/segmentation-3.0
+ * https://huggingface.co/pyannote/speaker-diarization-3.0
+
+ Note: To control the recognized speakers in the diarization output you can choose one of the following methods:
+
+ * For a known speakers amount, you may set speaker labels via the `speakers_labels` parameter that will be used in
+ the order of speaking in the audio (first person speaking be the first label in the list). In addition, you can do
+ diarization per channel (setting the parameter `separate_by_channels` to True). Each label will be assigned to a
+ specific channel by order (first label to channel 0, second label to channel 1 and so on). Notice, this will
+ increase runtime.
+ * For unknown speakers amount, you can set the `speaker_prefix` parameter to add a prefix for each speaker number.
+ You can also help the diarization by setting the speakers range via the `speakers_amount_range` parameter.
+
+ :param data_path: A directory of the audio files, a single file or a list of files to transcribe.
+ :param model_name: One of the official diarization model names (referred as diarization pipelines) of
+ `pyannote.audio` Huggingface page. Default: "pyannote/speaker-diarization-3.0".
+ :param access_token: An access token to pass for using the `pyannote.audio` models. If not provided, it
+ will be looking for the environment variable "HUGGING_FACE_HUB_TOKEN". If MLRun is
+ available, it will look for a secret "HUGGING_FACE_HUB_TOKEN".
+ :param device: Device to load the model. Can be one of {"cuda", "cpu"}. Default will prefer "cuda" if
+ available.
+ :param speakers_labels: Labels to use for the recognized speakers. Default: numeric labels (0, 1, ...).
+ :param separate_by_channels: If each speaker is speaking in a separate channel, you can diarize each channel and
+ combine the result into a single diarization. Each label set in the `speakers_labels`
+ parameter will be assigned to a specific channel by order.
+ :param speaker_prefix: A prefix to add for the speakers labels. This parameter is ignored if
+ `speakers_labels` is not None. Default: "speaker".
+ :param minimum_speakers: Set the minimum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param maximum_speakers: Set the maximum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param verbose: Whether to present logs of a progress bar and errors. Default: True.
+
+ :returns: A tuple of:
+
+ * Speech diarization dictionary.
+ * A dictionary of errored files that were not transcribed.
+ """
+ global _LOGGER
+
+ # Get the input audio files to diarize:
+ if isinstance(data_path, str):
+ data_path = pathlib.Path(data_path).absolute()
+ audio_files = _get_audio_files(data_path=data_path)
+ else: # Should be a list of files.
+ audio_files = data_path
+
+ # Get the Huggingface access token:
+ access_token = _get_access_token(parameter=access_token)
+ if access_token is None:
+ raise ValueError(
+ "A Huggingface access token must be provided to use `pyannote.audio` models. Access token can be passed "
+ "via one of the following options:\n"
+ "* Use the parameter `access_token`.\n"
+ "* Set an environment variable named 'HUGGING_FACE_HUB_TOKEN'.\n"
+ "* If using MLRun, you can pass it as a secret named 'HUGGING_FACE_HUB_TOKEN'."
+ )
+
+ # Load the diarization pipeline:
+ pipeline = pyannote.audio.Pipeline.from_pretrained(
+ checkpoint_path=model_name, use_auth_token=access_token
+ )
+
+ # Set the device:
+ device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+ if device != "cpu":
+ pipeline.to(torch.device(device))
+
+ # Prepare the successes dataframe and errors dictionary to be returned:
+ diarizations = {}
+ errors = {}
+
+ # Prepare the diarization keyword arguments:
+ diarize_kwargs = {}
+ if speakers_labels:
+ diarize_kwargs["num_speakers"] = len(speakers_labels)
+ else:
+ if minimum_speakers:
+ diarize_kwargs["min_speakers"] = minimum_speakers
+ if maximum_speakers:
+ diarize_kwargs["max_speakers"] = maximum_speakers
+
+ # Go over the audio files and diarize:
+ for audio_file in tqdm(
+ audio_files, desc="Diarizing", unit="file", disable=not verbose
+ ):
+ try:
+ # Load audio file:
+ audio, sample_rate = torchaudio.load(uri=audio_file, channels_first=True)
+ # Get the diarization (if provided):
+ diarizations[audio_file.name] = _diarize(
+ audio=audio,
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=speakers_labels,
+ separate_by_channels=separate_by_channels,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs=diarize_kwargs,
+ )
+ except Exception as exception:
+ # Note the exception as error in the dictionary:
+ if verbose:
+ _LOGGER.warning(f"Error in file: '{audio_file.name}'")
+ errors[str(audio_file.name)] = str(exception)
+ continue
+
+ # Print the head of the produced dataframe and return:
+ if verbose:
+ _LOGGER.info(f"Done ({len(diarizations)}/{len(audio_files)})\n")
+ return diarizations, errors
+
+
+def _get_audio_files(
+ data_path: pathlib.Path,
+) -> List[pathlib.Path]:
+ # Check if the path is of a directory or a file:
+ if data_path.is_dir():
+ # Get all files inside the directory:
+ audio_files = list(data_path.glob("*.*"))
+ elif data_path.is_file():
+ audio_files = [data_path]
+ else:
+ raise ValueError(
+ f"Unrecognized data path. The parameter `data_path` must be either a directory path or a file path. "
+ f"Given: {str(data_path)} "
+ )
+
+ return audio_files
+
+
+def _get_access_token(parameter: str) -> str:
+ # If given as a parameter, return it:
+ if parameter:
+ return parameter
+
+ # Otherwise, look at the environment variable:
+ environment_variable = os.environ.get("HUGGING_FACE_HUB_TOKEN")
+ if environment_variable:
+ return environment_variable
+
+ # Lastly, try look in the set secrets in MLRun:
+ secret = None
+ try:
+ import mlrun
+
+ context = mlrun.get_or_create_ctx(name="mlrun")
+ secret = context.get_secret(key="HUGGING_FACE_HUB_TOKEN")
+ except ModuleNotFoundError:
+ pass
+
+ return secret
+
+
+def _diarize(
+ audio: torch.Tensor,
+ sample_rate: int,
+ pipeline: pyannote.audio.Pipeline,
+ speakers_labels: List[str],
+ separate_by_channels: bool,
+ speaker_prefix: str,
+ diarize_kwargs: dict,
+) -> List[Tuple[float, float, str]]:
+ # If there is no need for separation by channels, we diarize and return:
+ if not separate_by_channels:
+ # Diarize:
+ diarization: pyannote.core.Annotation = pipeline(
+ file={"waveform": audio, "sample_rate": sample_rate}, **diarize_kwargs
+ )
+ # Verify speakers labels (should not fail here as we set `num_speakers=len(speakers_labels)` when inferring
+ # through the pipeline):
+ if speakers_labels:
+ given_speakers = len(speakers_labels)
+ found_speakers = len(set(diarization.labels()))
+ if given_speakers < found_speakers:
+ raise ValueError(
+ f"Not enough `speakers_labels` were given. Got {given_speakers} labels but the diarization "
+ f"recognized {found_speakers} speakers."
+ )
+ # Return as a diarization list - a sorted list of tuples of start time, end time and a label (the default label
+ # returned is "SPEAKER_i" so we take only the index out of it):
+ return [
+ (
+ segment.start,
+ segment.end,
+ speakers_labels[int(label.split("_")[1])]
+ if speakers_labels
+ else f"{speaker_prefix}{int(label.split('_')[1])}",
+ )
+ for segment, track, label in diarization.itertracks(yield_label=True)
+ ]
+
+ # Separate to channels and diarize (we expect only one speaker per channel):
+ channel_diarizations = [
+ _diarize(
+ audio=audio[channel].unsqueeze(
+ 0
+ ), # Take channel and add a channel dimension to it.
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=[
+ speakers_labels[channel]
+ ], # Take the channel's label only.
+ separate_by_channels=False,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs={"num_speakers": 1}, # Set to one speaker.
+ )
+ for channel in range(audio.shape[0])
+ ]
+
+ # Merge the channel diarizations into a single sorted list:
+ return list(heapq.merge(*channel_diarizations))
diff --git a/functions/development/pyannote_audio/1.1.0/src/test_pyannote_audio.py b/functions/development/pyannote_audio/1.1.0/src/test_pyannote_audio.py
new file mode 100644
index 00000000..93da5083
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/src/test_pyannote_audio.py
@@ -0,0 +1,25 @@
+import os
+
+import mlrun
+import pytest
+
+
+@pytest.mark.skipif("HUGGING_FACE_HUB_TOKEN" not in os.environ, reason="no token")
+def test_speech_diarization():
+ project = mlrun.new_project("diarization-test2")
+ speech_diarization = project.set_function(
+ func="./function.yaml", name="speech_diarization", image="mlrun/mlrun"
+ )
+
+ diarize_run = speech_diarization.run(
+ handler="diarize",
+ inputs={"data_path": os.path.join("assets", "test_data.wav")},
+ params={
+ "device": "cpu",
+ "speakers_labels": ["Agent", "Client"],
+ "separate_by_channels": True,
+ },
+ returns=["speech_diarization: file", "diarize_errors: file"],
+ local=True,
+ )
+ assert diarize_run.outputs["speech_diarization"]
diff --git a/functions/development/pyannote_audio/1.1.0/static/documentation.html b/functions/development/pyannote_audio/1.1.0/static/documentation.html
new file mode 100644
index 00000000..1fdd1cf3
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/static/documentation.html
@@ -0,0 +1,289 @@
+
+
+
+
+
+
+
+pyannote_audio package
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).
+The end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+of tuples: (start, end, speaker_label).
+
To use the pyannote.audio models you must pass a Huggingface token and get access to the required models. The
+token can be passed in one of the following options:
+
+
Use the parameter access_token.
+
Set an environment variable named “HUGGING_FACE_HUB_TOKEN”.
+
If using MLRun, you can pass it as a secret named “HUGGING_FACE_HUB_TOKEN”.
+
+
To get access to the models on Huggingface, visit their page. For example, to use the default diarization model set
+in this function (“pyannote/speaker-diarization-3.0”), you need access for these two models:
Note: To control the recognized speakers in the diarization output you can choose one of the following methods:
+
+
For a known speakers amount, you may set speaker labels via the speakers_labels parameter that will be used in
+the order of speaking in the audio (first person speaking be the first label in the list). In addition, you can do
+diarization per channel (setting the parameter separate_by_channels to True). Each label will be assigned to a
+specific channel by order (first label to channel 0, second label to channel 1 and so on). Notice, this will
+increase runtime.
+
For unknown speakers amount, you can set the speaker_prefix parameter to add a prefix for each speaker number.
+You can also help the diarization by setting the speakers range via the speakers_amount_range parameter.
+
+
+
Parameters
+
+
data_path – A directory of the audio files, a single file or a list of files to transcribe.
+
model_name – One of the official diarization model names (referred as diarization pipelines) of
+pyannote.audio Huggingface page. Default: “pyannote/speaker-diarization-3.0”.
+
access_token – An access token to pass for using the pyannote.audio models. If not provided, it
+will be looking for the environment variable “HUGGING_FACE_HUB_TOKEN”. If MLRun is
+available, it will look for a secret “HUGGING_FACE_HUB_TOKEN”.
+
device – Device to load the model. Can be one of {“cuda”, “cpu”}. Default will prefer “cuda” if
+available.
+
speakers_labels – Labels to use for the recognized speakers. Default: numeric labels (0, 1, …).
+
separate_by_channels – If each speaker is speaking in a separate channel, you can diarize each channel and
+combine the result into a single diarization. Each label set in the speakers_labels
+parameter will be assigned to a specific channel by order.
+
speaker_prefix – A prefix to add for the speakers labels. This parameter is ignored if
+speakers_labels is not None. Default: “speaker”.
+
minimum_speakers – Set the minimum expected amount of speakers to be in the audio files. This parameter is
+ignored if speakers_labels is not None.
+
maximum_speakers – Set the maximum expected amount of speakers to be in the audio files. This parameter is
+ignored if speakers_labels is not None.
+
verbose – Whether to present logs of a progress bar and errors. Default: True.
+
+
+
Returns
+
A tuple of:
+
+
Speech diarization dictionary.
+
A dictionary of errored files that were not transcribed.
In this notebook we will utilize a call diarization capability to get per-speaker speech durations from a call recording.
+This can be useful for quantifying participation rates in calls for things like customer service analysis.
+
We will demonstrate this by:
+
+
Loading in a sample call recording between multiple participants
+
Using a diarize() function to automatically detect speakers and estimate per-speaker talk time
+
Return a dictionary of described results, and a df of errors
+
+
+
+
importos
+importmlrun
+
+
+
+
+
+
+
# To use the `pyannote.audio` models you must pass a Huggingface token and get access to the required models. The
+# token can be passed in one of the following options:
+#
+# * Use the parameter `access_token`.
+# * Set an environment variable named "HUGGING_FACE_HUB_TOKEN".
+# * If using MLRun, you can pass it as a secret named "HUGGING_FACE_HUB_TOKEN".
+os.environ["HUGGING_FACE_HUB_TOKEN"]=<"add your token here">
+
+
+
+
+
+
+
# Create an mlrun project
+project=mlrun.get_or_create_project("diarization-test")
+
+# Import the function from the yaml file, once it's in the the we can import from there
+speech_diarization=project.set_function(func="hub://speech_diarization",name="speech_diarization")
+
# Set the desired run params and files
+audio_files=os.path.join("test_data.wav")
+device="cpu"
+speakers_labels=["Agent","Client"]
+separate_by_channels=True
+
+
+
+
+
+
+
# Run the imported function with desired file/s and params
+diarize_run=speech_diarization.run(
+ handler="diarize",
+ inputs={"data_path":audio_files},
+ params={
+ "device":device,
+ "speakers_labels":speakers_labels,
+ "separate_by_channels":separate_by_channels,
+ },
+ returns=["speech-diarization: file","diarize-errors: file"],
+ local=True,
+)
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/pyannote_audio/1.1.0/static/function.html b/functions/development/pyannote_audio/1.1.0/static/function.html
new file mode 100644
index 00000000..1d34bd5c
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/static/function.html
@@ -0,0 +1,173 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+
+kind: job
+metadata:
+ name: pyannote-audio
+ tag: ''
+ hash: c45be8d7f51f0b2203155b08c307814a2cb0ac78
+ project: ''
+ labels:
+ author: guyl
+ categories:
+ - deep-learning
+ - Huggingface
+ - Audio
+spec:
+ command: ''
+ args: []
+ image: ''
+ build:
+ functionSourceCode: # Copyright 2023 Iguazio
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import heapq
import logging
import operator
import os
import pathlib
from functools import reduce, wraps
from typing import Any, Dict, List, Tuple, Union

import pandas as pd
import pyannote.audio
import pyannote.core
import torch
import torchaudio
from tqdm import tqdm

# Get the global logger:
_LOGGER = logging.getLogger()


def _check_mlrun_and_open_mpi() -> Tuple["mlrun.MLClientCtx", "mpi4py.MPI.Intracomm"]:
    is_mpi = False
    try:
        import mlrun

        context = mlrun.get_or_create_ctx(name="mlrun")
        is_mpi = context.labels.get("kind", "job") == "mpijob"

        if is_mpi:
            try:
                from mpi4py import MPI

                return context, MPI.COMM_WORLD
            except ModuleNotFoundError as mpi4py_not_found:
                context.logger.error(
                    "To distribute the function using MLRun's 'mpijob' you need to have `mpi4py` package in your "
                    "interpreter. Please run `pip install mpi4py` and make sure you have open-mpi."
                )
                raise mpi4py_not_found
        else:
            return context, None
    except ModuleNotFoundError as module_not_found:
        if is_mpi:
            raise module_not_found
    return None, None


def open_mpi_handler(
    worker_inputs: List[str], root_worker_inputs: Dict[str, Any] = None
):
    global _LOGGER

    # Check for MLRun and OpenMPI availability:
    context, comm = _check_mlrun_and_open_mpi()

    # Check if MLRun is available, set the global logger to MLRun's:
    if context:
        _LOGGER = context.logger

    def decorator(handler):
        if comm is None or comm.Get_size() == 1:
            return handler

        @wraps(handler)
        def wrapper(**kwargs):
            # Get the open mpi environment properties:
            size = comm.Get_size()
            rank = comm.Get_rank()

            # Give the correct chunk of the workers inputs:
            for worker_input in worker_inputs:
                input_argument = kwargs[worker_input]
                if input_argument is None:
                    continue
                if isinstance(input_argument, str):
                    input_argument = _get_audio_files(
                        data_path=pathlib.Path(input_argument).absolute()
                    )
                if len(input_argument) < size:
                    raise ValueError(
                        f"Cannot split the input '{worker_input}' of length {len(input_argument)} to {size} workers. "
                        f"Please reduce the amount of workers for this input."
                    )
                even_chunk_size = len(input_argument) // size
                chunk_start = rank * even_chunk_size
                chunk_end = (
                    (rank + 1) * even_chunk_size
                    if rank + 1 < size
                    else len(input_argument)
                )
                context.logger.info(
                    f"Rank #{rank}: Processing input chunk of '{worker_input}' "
                    f"from index {chunk_start} to {chunk_end}."
                )
                if isinstance(input_argument, list):
                    input_argument = input_argument[chunk_start:chunk_end]
                elif isinstance(input_argument, pd.DataFrame):
                    input_argument = input_argument.iloc[chunk_start:chunk_end:, :]
                kwargs[worker_input] = input_argument

            # Set the root worker only arguments:
            if rank == 0 and root_worker_inputs:
                kwargs.update(root_worker_inputs)

            # Run the worker:
            output = handler(**kwargs)

            # Send the output to the root rank (rank #0):
            output = comm.gather(output, root=0)
            if rank == 0:
                # Join the outputs:
                context.logger.info("Collecting data from workers to root worker.")
                diarization_dictionary = reduce(
                    operator.ior, [dia for dia, _ in output], {}
                )
                errors_dictionary = reduce(operator.ior, [err for _, err in output], {})
                return diarization_dictionary, errors_dictionary
            return None

        return wrapper

    return decorator


@open_mpi_handler(worker_inputs=["data_path"], root_worker_inputs={"verbose": True})
def diarize(
    data_path: Union[str, List[str]],
    model_name: str = "pyannote/speaker-diarization-3.0",
    access_token: str = None,
    device: str = None,
    speakers_labels: List[str] = None,
    speaker_prefix: str = "speaker_",
    separate_by_channels: bool = False,
    minimum_speakers: int = None,
    maximum_speakers: int = None,
    verbose: bool = False,
) -> Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]:
    """
    Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).
    The end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
    of tuples: (start, end, speaker_label).

    To use the `pyannote.audio` models you must pass a Huggingface token and get access to the required models. The
    token can be passed in one of the following options:

    * Use the parameter `access_token`.
    * Set an environment variable named "HUGGING_FACE_HUB_TOKEN".
    * If using MLRun, you can pass it as a secret named "HUGGING_FACE_HUB_TOKEN".

    To get access to the models on Huggingface, visit their page. For example, to use the default diarization model set
    in this function ("pyannote/speaker-diarization-3.0"), you need access for these two models:

    * https://huggingface.co/pyannote/segmentation-3.0
    * https://huggingface.co/pyannote/speaker-diarization-3.0

    Note: To control the recognized speakers in the diarization output you can choose one of the following methods:

    * For a known speakers amount, you may set speaker labels via the `speakers_labels` parameter that will be used in
      the order of speaking in the audio (first person speaking be the first label in the list). In addition, you can do
      diarization per channel (setting the parameter `separate_by_channels` to True). Each label will be assigned to a
      specific channel by order (first label to channel 0, second label to channel 1 and so on). Notice, this will
      increase runtime.
    * For unknown speakers amount, you can set the `speaker_prefix` parameter to add a prefix for each speaker number.
      You can also help the diarization by setting the speakers range via the `speakers_amount_range` parameter.

    :param data_path:            A directory of the audio files, a single file or a list of files to transcribe.
    :param model_name:           One of the official diarization model names (referred as diarization pipelines) of
                                 `pyannote.audio` Huggingface page. Default: "pyannote/speaker-diarization-3.0".
    :param access_token:         An access token to pass for using the `pyannote.audio` models. If not provided, it
                                 will be looking for the environment variable "HUGGING_FACE_HUB_TOKEN". If MLRun is
                                 available, it will look for a secret "HUGGING_FACE_HUB_TOKEN".
    :param device:               Device to load the model. Can be one of {"cuda", "cpu"}. Default will prefer "cuda" if
                                 available.
    :param speakers_labels:      Labels to use for the recognized speakers. Default: numeric labels (0, 1, ...).
    :param separate_by_channels: If each speaker is speaking in a separate channel, you can diarize each channel and
                                 combine the result into a single diarization. Each label set in the `speakers_labels`
                                 parameter will be assigned to a specific channel by order.
    :param speaker_prefix:       A prefix to add for the speakers labels. This parameter is ignored if
                                 `speakers_labels` is not None. Default: "speaker".
    :param minimum_speakers:     Set the minimum expected amount of speakers to be in the audio files. This parameter is
                                 ignored if `speakers_labels` is not None.
    :param maximum_speakers:     Set the maximum expected amount of speakers to be in the audio files. This parameter is
                                 ignored if `speakers_labels` is not None.
    :param verbose:              Whether to present logs of a progress bar and errors. Default: True.

    :returns: A tuple of:

              * Speech diarization dictionary.
              * A dictionary of errored files that were not transcribed.
    """
    global _LOGGER

    # Get the input audio files to diarize:
    if isinstance(data_path, str):
        data_path = pathlib.Path(data_path).absolute()
        audio_files = _get_audio_files(data_path=data_path)
    else:  # Should be a list of files.
        audio_files = data_path

    # Get the Huggingface access token:
    access_token = _get_access_token(parameter=access_token)
    if access_token is None:
        raise ValueError(
            "A Huggingface access token must be provided to use `pyannote.audio` models. Access token can be passed "
            "via one of the following options:\n"
            "* Use the parameter `access_token`.\n"
            "* Set an environment variable named 'HUGGING_FACE_HUB_TOKEN'.\n"
            "* If using MLRun, you can pass it as a secret named 'HUGGING_FACE_HUB_TOKEN'."
        )

    # Load the diarization pipeline:
    pipeline = pyannote.audio.Pipeline.from_pretrained(
        checkpoint_path=model_name, use_auth_token=access_token
    )

    # Set the device:
    device = device or ("cuda" if torch.cuda.is_available() else "cpu")
    if device != "cpu":
        pipeline.to(torch.device(device))

    # Prepare the successes dataframe and errors dictionary to be returned:
    diarizations = {}
    errors = {}

    # Prepare the diarization keyword arguments:
    diarize_kwargs = {}
    if speakers_labels:
        diarize_kwargs["num_speakers"] = len(speakers_labels)
    else:
        if minimum_speakers:
            diarize_kwargs["min_speakers"] = minimum_speakers
        if maximum_speakers:
            diarize_kwargs["max_speakers"] = maximum_speakers

    # Go over the audio files and diarize:
    for audio_file in tqdm(
        audio_files, desc="Diarizing", unit="file", disable=not verbose
    ):
        try:
            # Load audio file:
            audio, sample_rate = torchaudio.load(uri=audio_file, channels_first=True)
            # Get the diarization (if provided):
            diarizations[audio_file.name] = _diarize(
                audio=audio,
                sample_rate=sample_rate,
                pipeline=pipeline,
                speakers_labels=speakers_labels,
                separate_by_channels=separate_by_channels,
                speaker_prefix=speaker_prefix,
                diarize_kwargs=diarize_kwargs,
            )
        except Exception as exception:
            # Note the exception as error in the dictionary:
            if verbose:
                _LOGGER.warning(f"Error in file: '{audio_file.name}'")
            errors[str(audio_file.name)] = str(exception)
            continue

    # Print the head of the produced dataframe and return:
    if verbose:
        _LOGGER.info(f"Done ({len(diarizations)}/{len(audio_files)})\n")
    return diarizations, errors


def _get_audio_files(
    data_path: pathlib.Path,
) -> List[pathlib.Path]:
    # Check if the path is of a directory or a file:
    if data_path.is_dir():
        # Get all files inside the directory:
        audio_files = list(data_path.glob("*.*"))
    elif data_path.is_file():
        audio_files = [data_path]
    else:
        raise ValueError(
            f"Unrecognized data path. The parameter `data_path` must be either a directory path or a file path. "
            f"Given: {str(data_path)} "
        )

    return audio_files


def _get_access_token(parameter: str) -> str:
    # If given as a parameter, return it:
    if parameter:
        return parameter

    # Otherwise, look at the environment variable:
    environment_variable = os.environ.get("HUGGING_FACE_HUB_TOKEN")
    if environment_variable:
        return environment_variable

    # Lastly, try look in the set secrets in MLRun:
    secret = None
    try:
        import mlrun

        context = mlrun.get_or_create_ctx(name="mlrun")
        secret = context.get_secret(key="HUGGING_FACE_HUB_TOKEN")
    except ModuleNotFoundError:
        pass

    return secret


def _diarize(
    audio: torch.Tensor,
    sample_rate: int,
    pipeline: pyannote.audio.Pipeline,
    speakers_labels: List[str],
    separate_by_channels: bool,
    speaker_prefix: str,
    diarize_kwargs: dict,
) -> List[Tuple[float, float, str]]:
    # If there is no need for separation by channels, we diarize and return:
    if not separate_by_channels:
        # Diarize:
        diarization: pyannote.core.Annotation = pipeline(
            file={"waveform": audio, "sample_rate": sample_rate}, **diarize_kwargs
        )
        # Verify speakers labels (should not fail here as we set `num_speakers=len(speakers_labels)` when inferring
        # through the pipeline):
        if speakers_labels:
            given_speakers = len(speakers_labels)
            found_speakers = len(set(diarization.labels()))
            if given_speakers < found_speakers:
                raise ValueError(
                    f"Not enough `speakers_labels` were given. Got {given_speakers} labels but the diarization "
                    f"recognized {found_speakers} speakers."
                )
        # Return as a diarization list - a sorted list of tuples of start time, end time and a label (the default label
        # returned is "SPEAKER_i" so we take only the index out of it):
        return [
            (
                segment.start,
                segment.end,
                speakers_labels[int(label.split("_")[1])]
                if speakers_labels
                else f"{speaker_prefix}{int(label.split('_')[1])}",
            )
            for segment, track, label in diarization.itertracks(yield_label=True)
        ]

    # Separate to channels and diarize (we expect only one speaker per channel):
    channel_diarizations = [
        _diarize(
            audio=audio[channel].unsqueeze(
                0
            ),  # Take channel and add a channel dimension to it.
            sample_rate=sample_rate,
            pipeline=pipeline,
            speakers_labels=[
                speakers_labels[channel]
            ],  # Take the channel's label only.
            separate_by_channels=False,
            speaker_prefix=speaker_prefix,
            diarize_kwargs={"num_speakers": 1},  # Set to one speaker.
        )
        for channel in range(audio.shape[0])
    ]

    # Merge the channel diarizations into a single sorted list:
    return list(heapq.merge(*channel_diarizations))

+ base_image: mlrun/mlrun-gpu
+ commands: []
+ code_origin: ''
+ origin_filename: ''
+ requirements:
+ - pyannote.audio
+ - pyannote.core
+ - torchaudio
+ - tqdm
+ entry_points:
+ open_mpi_handler:
+ name: open_mpi_handler
+ doc: ''
+ parameters:
+ - name: worker_inputs
+ type: List[str]
+ - name: root_worker_inputs
+ type: Dict[str, Any]
+ default: null
+ outputs: []
+ lineno: 61
+ has_varargs: false
+ has_kwargs: false
+ decorator:
+ name: decorator
+ doc: ''
+ parameters:
+ - name: handler
+ outputs: []
+ lineno: 73
+ has_varargs: false
+ has_kwargs: false
+ wrapper:
+ name: wrapper
+ doc: ''
+ parameters: []
+ outputs: []
+ lineno: 78
+ has_varargs: false
+ has_kwargs: true
+ diarize:
+ name: diarize
+ doc: "Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).\n\
+ The end result is a dictionary with the file names as keys and their diarization\
+ \ as value. A diarization is a list\nof tuples: (start, end, speaker_label).\n\
+ \nTo use the `pyannote.audio` models you must pass a Huggingface token and\
+ \ get access to the required models. The\ntoken can be passed in one of the\
+ \ following options:\n\n* Use the parameter `access_token`.\n* Set an environment\
+ \ variable named \"HUGGING_FACE_HUB_TOKEN\".\n* If using MLRun, you can pass\
+ \ it as a secret named \"HUGGING_FACE_HUB_TOKEN\".\n\nTo get access to the\
+ \ models on Huggingface, visit their page. For example, to use the default\
+ \ diarization model set\nin this function (\"pyannote/speaker-diarization-3.0\"\
+ ), you need access for these two models:\n\n* https://huggingface.co/pyannote/segmentation-3.0\n\
+ * https://huggingface.co/pyannote/speaker-diarization-3.0\n\nNote: To control\
+ \ the recognized speakers in the diarization output you can choose one of\
+ \ the following methods:\n\n* For a known speakers amount, you may set speaker\
+ \ labels via the `speakers_labels` parameter that will be used in\n the order\
+ \ of speaking in the audio (first person speaking be the first label in the\
+ \ list). In addition, you can do\n diarization per channel (setting the parameter\
+ \ `separate_by_channels` to True). Each label will be assigned to a\n specific\
+ \ channel by order (first label to channel 0, second label to channel 1 and\
+ \ so on). Notice, this will\n increase runtime.\n* For unknown speakers amount,\
+ \ you can set the `speaker_prefix` parameter to add a prefix for each speaker\
+ \ number.\n You can also help the diarization by setting the speakers range\
+ \ via the `speakers_amount_range` parameter."
+ parameters:
+ - name: data_path
+ type: Union[str, List[str]]
+ doc: A directory of the audio files, a single file or a list of files to transcribe.
+ - name: model_name
+ type: str
+ doc: 'One of the official diarization model names (referred as diarization
+ pipelines) of `pyannote.audio` Huggingface page. Default: "pyannote/speaker-diarization-3.0".'
+ default: pyannote/speaker-diarization-3.0
+ - name: access_token
+ type: str
+ doc: An access token to pass for using the `pyannote.audio` models. If not
+ provided, it will be looking for the environment variable "HUGGING_FACE_HUB_TOKEN".
+ If MLRun is available, it will look for a secret "HUGGING_FACE_HUB_TOKEN".
+ default: null
+ - name: device
+ type: str
+ doc: Device to load the model. Can be one of {"cuda", "cpu"}. Default will
+ prefer "cuda" if available.
+ default: null
+ - name: speakers_labels
+ type: List[str]
+ doc: 'Labels to use for the recognized speakers. Default: numeric labels (0,
+ 1, ...).'
+ default: null
+ - name: speaker_prefix
+ type: str
+ doc: 'A prefix to add for the speakers labels. This parameter is ignored if
+ `speakers_labels` is not None. Default: "speaker".'
+ default: speaker_
+ - name: separate_by_channels
+ type: bool
+ doc: If each speaker is speaking in a separate channel, you can diarize each
+ channel and combine the result into a single diarization. Each label set
+ in the `speakers_labels` parameter will be assigned to a specific channel
+ by order.
+ default: false
+ - name: minimum_speakers
+ type: int
+ doc: Set the minimum expected amount of speakers to be in the audio files.
+ This parameter is ignored if `speakers_labels` is not None.
+ default: null
+ - name: maximum_speakers
+ type: int
+ doc: Set the maximum expected amount of speakers to be in the audio files.
+ This parameter is ignored if `speakers_labels` is not None.
+ default: null
+ - name: verbose
+ type: bool
+ doc: 'Whether to present logs of a progress bar and errors. Default: True.'
+ default: false
+ outputs:
+ - doc: 'A tuple of:'
+ type: Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]
+ lineno: 139
+ has_varargs: false
+ has_kwargs: false
+ description: pyannote's speech diarization of audio files
+ default_handler: diarize
+ disable_auto_mount: false
+ clone_target_dir: ''
+ env: []
+ priority_class_name: ''
+ preemption_mode: prevent
+ affinity: null
+ tolerations: null
+ security_context: {}
+verbose: false
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/pyannote_audio/1.1.0/static/item.html b/functions/development/pyannote_audio/1.1.0/static/item.html
new file mode 100644
index 00000000..2b5611bb
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/static/item.html
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+importheapq
+importlogging
+importoperator
+importos
+importpathlib
+fromfunctoolsimportreduce,wraps
+fromtypingimportAny,Dict,List,Tuple,Union
+
+importpandasaspd
+importpyannote.audio
+importpyannote.core
+importtorch
+importtorchaudio
+fromtqdmimporttqdm
+
+# Get the global logger:
+_LOGGER=logging.getLogger()
+
+
+def_check_mlrun_and_open_mpi()->Tuple["mlrun.MLClientCtx","mpi4py.MPI.Intracomm"]:
+ is_mpi=False
+ try:
+ importmlrun
+
+ context=mlrun.get_or_create_ctx(name="mlrun")
+ is_mpi=context.labels.get("kind","job")=="mpijob"
+
+ ifis_mpi:
+ try:
+ frommpi4pyimportMPI
+
+ returncontext,MPI.COMM_WORLD
+ exceptModuleNotFoundErrorasmpi4py_not_found:
+ context.logger.error(
+ "To distribute the function using MLRun's 'mpijob' you need to have `mpi4py` package in your "
+ "interpreter. Please run `pip install mpi4py` and make sure you have open-mpi."
+ )
+ raisempi4py_not_found
+ else:
+ returncontext,None
+ exceptModuleNotFoundErrorasmodule_not_found:
+ ifis_mpi:
+ raisemodule_not_found
+ returnNone,None
+
+
+
[docs]defopen_mpi_handler(
+ worker_inputs:List[str],root_worker_inputs:Dict[str,Any]=None
+):
+ global_LOGGER
+
+ # Check for MLRun and OpenMPI availability:
+ context,comm=_check_mlrun_and_open_mpi()
+
+ # Check if MLRun is available, set the global logger to MLRun's:
+ ifcontext:
+ _LOGGER=context.logger
+
+ defdecorator(handler):
+ ifcommisNoneorcomm.Get_size()==1:
+ returnhandler
+
+ @wraps(handler)
+ defwrapper(**kwargs):
+ # Get the open mpi environment properties:
+ size=comm.Get_size()
+ rank=comm.Get_rank()
+
+ # Give the correct chunk of the workers inputs:
+ forworker_inputinworker_inputs:
+ input_argument=kwargs[worker_input]
+ ifinput_argumentisNone:
+ continue
+ ifisinstance(input_argument,str):
+ input_argument=_get_audio_files(
+ data_path=pathlib.Path(input_argument).absolute()
+ )
+ iflen(input_argument)<size:
+ raiseValueError(
+ f"Cannot split the input '{worker_input}' of length {len(input_argument)} to {size} workers. "
+ f"Please reduce the amount of workers for this input."
+ )
+ even_chunk_size=len(input_argument)//size
+ chunk_start=rank*even_chunk_size
+ chunk_end=(
+ (rank+1)*even_chunk_size
+ ifrank+1<size
+ elselen(input_argument)
+ )
+ context.logger.info(
+ f"Rank #{rank}: Processing input chunk of '{worker_input}' "
+ f"from index {chunk_start} to {chunk_end}."
+ )
+ ifisinstance(input_argument,list):
+ input_argument=input_argument[chunk_start:chunk_end]
+ elifisinstance(input_argument,pd.DataFrame):
+ input_argument=input_argument.iloc[chunk_start:chunk_end:,:]
+ kwargs[worker_input]=input_argument
+
+ # Set the root worker only arguments:
+ ifrank==0androot_worker_inputs:
+ kwargs.update(root_worker_inputs)
+
+ # Run the worker:
+ output=handler(**kwargs)
+
+ # Send the output to the root rank (rank #0):
+ output=comm.gather(output,root=0)
+ ifrank==0:
+ # Join the outputs:
+ context.logger.info("Collecting data from workers to root worker.")
+ diarization_dictionary=reduce(
+ operator.ior,[diafordia,_inoutput],{}
+ )
+ errors_dictionary=reduce(operator.ior,[errfor_,errinoutput],{})
+ returndiarization_dictionary,errors_dictionary
+ returnNone
+
+ returnwrapper
+
+ returndecorator
+
+
+
[docs]@open_mpi_handler(worker_inputs=["data_path"],root_worker_inputs={"verbose":True})
+defdiarize(
+ data_path:Union[str,List[str]],
+ model_name:str="pyannote/speaker-diarization-3.0",
+ access_token:str=None,
+ device:str=None,
+ speakers_labels:List[str]=None,
+ speaker_prefix:str="speaker_",
+ separate_by_channels:bool=False,
+ minimum_speakers:int=None,
+ maximum_speakers:int=None,
+ verbose:bool=False,
+)->Tuple[Dict[str,List[Tuple[float,float,str]]],Dict[str,str]]:
+"""
+ Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).
+ The end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ To use the `pyannote.audio` models you must pass a Huggingface token and get access to the required models. The
+ token can be passed in one of the following options:
+
+ * Use the parameter `access_token`.
+ * Set an environment variable named "HUGGING_FACE_HUB_TOKEN".
+ * If using MLRun, you can pass it as a secret named "HUGGING_FACE_HUB_TOKEN".
+
+ To get access to the models on Huggingface, visit their page. For example, to use the default diarization model set
+ in this function ("pyannote/speaker-diarization-3.0"), you need access for these two models:
+
+ * https://huggingface.co/pyannote/segmentation-3.0
+ * https://huggingface.co/pyannote/speaker-diarization-3.0
+
+ Note: To control the recognized speakers in the diarization output you can choose one of the following methods:
+
+ * For a known speakers amount, you may set speaker labels via the `speakers_labels` parameter that will be used in
+ the order of speaking in the audio (first person speaking be the first label in the list). In addition, you can do
+ diarization per channel (setting the parameter `separate_by_channels` to True). Each label will be assigned to a
+ specific channel by order (first label to channel 0, second label to channel 1 and so on). Notice, this will
+ increase runtime.
+ * For unknown speakers amount, you can set the `speaker_prefix` parameter to add a prefix for each speaker number.
+ You can also help the diarization by setting the speakers range via the `speakers_amount_range` parameter.
+
+ :param data_path: A directory of the audio files, a single file or a list of files to transcribe.
+ :param model_name: One of the official diarization model names (referred as diarization pipelines) of
+ `pyannote.audio` Huggingface page. Default: "pyannote/speaker-diarization-3.0".
+ :param access_token: An access token to pass for using the `pyannote.audio` models. If not provided, it
+ will be looking for the environment variable "HUGGING_FACE_HUB_TOKEN". If MLRun is
+ available, it will look for a secret "HUGGING_FACE_HUB_TOKEN".
+ :param device: Device to load the model. Can be one of {"cuda", "cpu"}. Default will prefer "cuda" if
+ available.
+ :param speakers_labels: Labels to use for the recognized speakers. Default: numeric labels (0, 1, ...).
+ :param separate_by_channels: If each speaker is speaking in a separate channel, you can diarize each channel and
+ combine the result into a single diarization. Each label set in the `speakers_labels`
+ parameter will be assigned to a specific channel by order.
+ :param speaker_prefix: A prefix to add for the speakers labels. This parameter is ignored if
+ `speakers_labels` is not None. Default: "speaker".
+ :param minimum_speakers: Set the minimum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param maximum_speakers: Set the maximum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param verbose: Whether to present logs of a progress bar and errors. Default: True.
+
+ :returns: A tuple of:
+
+ * Speech diarization dictionary.
+ * A dictionary of errored files that were not transcribed.
+ """
+ global_LOGGER
+
+ # Get the input audio files to diarize:
+ ifisinstance(data_path,str):
+ data_path=pathlib.Path(data_path).absolute()
+ audio_files=_get_audio_files(data_path=data_path)
+ else:# Should be a list of files.
+ audio_files=data_path
+
+ # Get the Huggingface access token:
+ access_token=_get_access_token(parameter=access_token)
+ ifaccess_tokenisNone:
+ raiseValueError(
+ "A Huggingface access token must be provided to use `pyannote.audio` models. Access token can be passed "
+ "via one of the following options:\n"
+ "* Use the parameter `access_token`.\n"
+ "* Set an environment variable named 'HUGGING_FACE_HUB_TOKEN'.\n"
+ "* If using MLRun, you can pass it as a secret named 'HUGGING_FACE_HUB_TOKEN'."
+ )
+
+ # Load the diarization pipeline:
+ pipeline=pyannote.audio.Pipeline.from_pretrained(
+ checkpoint_path=model_name,use_auth_token=access_token
+ )
+
+ # Set the device:
+ device=deviceor("cuda"iftorch.cuda.is_available()else"cpu")
+ ifdevice!="cpu":
+ pipeline.to(torch.device(device))
+
+ # Prepare the successes dataframe and errors dictionary to be returned:
+ diarizations={}
+ errors={}
+
+ # Prepare the diarization keyword arguments:
+ diarize_kwargs={}
+ ifspeakers_labels:
+ diarize_kwargs["num_speakers"]=len(speakers_labels)
+ else:
+ ifminimum_speakers:
+ diarize_kwargs["min_speakers"]=minimum_speakers
+ ifmaximum_speakers:
+ diarize_kwargs["max_speakers"]=maximum_speakers
+
+ # Go over the audio files and diarize:
+ foraudio_fileintqdm(
+ audio_files,desc="Diarizing",unit="file",disable=notverbose
+ ):
+ try:
+ # Load audio file:
+ audio,sample_rate=torchaudio.load(uri=audio_file,channels_first=True)
+ # Get the diarization (if provided):
+ diarizations[audio_file.name]=_diarize(
+ audio=audio,
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=speakers_labels,
+ separate_by_channels=separate_by_channels,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs=diarize_kwargs,
+ )
+ exceptExceptionasexception:
+ # Note the exception as error in the dictionary:
+ ifverbose:
+ _LOGGER.warning(f"Error in file: '{audio_file.name}'")
+ errors[str(audio_file.name)]=str(exception)
+ continue
+
+ # Print the head of the produced dataframe and return:
+ ifverbose:
+ _LOGGER.info(f"Done ({len(diarizations)}/{len(audio_files)})\n")
+ returndiarizations,errors
+
+
+def_get_audio_files(
+ data_path:pathlib.Path,
+)->List[pathlib.Path]:
+ # Check if the path is of a directory or a file:
+ ifdata_path.is_dir():
+ # Get all files inside the directory:
+ audio_files=list(data_path.glob("*.*"))
+ elifdata_path.is_file():
+ audio_files=[data_path]
+ else:
+ raiseValueError(
+ f"Unrecognized data path. The parameter `data_path` must be either a directory path or a file path. "
+ f"Given: {str(data_path)} "
+ )
+
+ returnaudio_files
+
+
+def_get_access_token(parameter:str)->str:
+ # If given as a parameter, return it:
+ ifparameter:
+ returnparameter
+
+ # Otherwise, look at the environment variable:
+ environment_variable=os.environ.get("HUGGING_FACE_HUB_TOKEN")
+ ifenvironment_variable:
+ returnenvironment_variable
+
+ # Lastly, try look in the set secrets in MLRun:
+ secret=None
+ try:
+ importmlrun
+
+ context=mlrun.get_or_create_ctx(name="mlrun")
+ secret=context.get_secret(key="HUGGING_FACE_HUB_TOKEN")
+ exceptModuleNotFoundError:
+ pass
+
+ returnsecret
+
+
+def_diarize(
+ audio:torch.Tensor,
+ sample_rate:int,
+ pipeline:pyannote.audio.Pipeline,
+ speakers_labels:List[str],
+ separate_by_channels:bool,
+ speaker_prefix:str,
+ diarize_kwargs:dict,
+)->List[Tuple[float,float,str]]:
+ # If there is no need for separation by channels, we diarize and return:
+ ifnotseparate_by_channels:
+ # Diarize:
+ diarization:pyannote.core.Annotation=pipeline(
+ file={"waveform":audio,"sample_rate":sample_rate},**diarize_kwargs
+ )
+ # Verify speakers labels (should not fail here as we set `num_speakers=len(speakers_labels)` when inferring
+ # through the pipeline):
+ ifspeakers_labels:
+ given_speakers=len(speakers_labels)
+ found_speakers=len(set(diarization.labels()))
+ ifgiven_speakers<found_speakers:
+ raiseValueError(
+ f"Not enough `speakers_labels` were given. Got {given_speakers} labels but the diarization "
+ f"recognized {found_speakers} speakers."
+ )
+ # Return as a diarization list - a sorted list of tuples of start time, end time and a label (the default label
+ # returned is "SPEAKER_i" so we take only the index out of it):
+ return[
+ (
+ segment.start,
+ segment.end,
+ speakers_labels[int(label.split("_")[1])]
+ ifspeakers_labels
+ elsef"{speaker_prefix}{int(label.split('_')[1])}",
+ )
+ forsegment,track,labelindiarization.itertracks(yield_label=True)
+ ]
+
+ # Separate to channels and diarize (we expect only one speaker per channel):
+ channel_diarizations=[
+ _diarize(
+ audio=audio[channel].unsqueeze(
+ 0
+ ),# Take channel and add a channel dimension to it.
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=[
+ speakers_labels[channel]
+ ],# Take the channel's label only.
+ separate_by_channels=False,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs={"num_speakers":1},# Set to one speaker.
+ )
+ forchannelinrange(audio.shape[0])
+ ]
+
+ # Merge the channel diarizations into a single sorted list:
+ returnlist(heapq.merge(*channel_diarizations))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/pyannote_audio/1.1.0/static/source.html b/functions/development/pyannote_audio/1.1.0/static/source.html
new file mode 100644
index 00000000..fe7d54cd
--- /dev/null
+++ b/functions/development/pyannote_audio/1.1.0/static/source.html
@@ -0,0 +1,398 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import heapq
+import logging
+import operator
+import os
+import pathlib
+from functools import reduce, wraps
+from typing import Any, Dict, List, Tuple, Union
+
+import pandas as pd
+import pyannote.audio
+import pyannote.core
+import torch
+import torchaudio
+from tqdm import tqdm
+
+# Get the global logger:
+_LOGGER = logging.getLogger()
+
+
+def _check_mlrun_and_open_mpi() -> Tuple["mlrun.MLClientCtx", "mpi4py.MPI.Intracomm"]:
+ is_mpi = False
+ try:
+ import mlrun
+
+ context = mlrun.get_or_create_ctx(name="mlrun")
+ is_mpi = context.labels.get("kind", "job") == "mpijob"
+
+ if is_mpi:
+ try:
+ from mpi4py import MPI
+
+ return context, MPI.COMM_WORLD
+ except ModuleNotFoundError as mpi4py_not_found:
+ context.logger.error(
+ "To distribute the function using MLRun's 'mpijob' you need to have `mpi4py` package in your "
+ "interpreter. Please run `pip install mpi4py` and make sure you have open-mpi."
+ )
+ raise mpi4py_not_found
+ else:
+ return context, None
+ except ModuleNotFoundError as module_not_found:
+ if is_mpi:
+ raise module_not_found
+ return None, None
+
+
+def open_mpi_handler(
+ worker_inputs: List[str], root_worker_inputs: Dict[str, Any] = None
+):
+ global _LOGGER
+
+ # Check for MLRun and OpenMPI availability:
+ context, comm = _check_mlrun_and_open_mpi()
+
+ # Check if MLRun is available, set the global logger to MLRun's:
+ if context:
+ _LOGGER = context.logger
+
+ def decorator(handler):
+ if comm is None or comm.Get_size() == 1:
+ return handler
+
+ @wraps(handler)
+ def wrapper(**kwargs):
+ # Get the open mpi environment properties:
+ size = comm.Get_size()
+ rank = comm.Get_rank()
+
+ # Give the correct chunk of the workers inputs:
+ for worker_input in worker_inputs:
+ input_argument = kwargs[worker_input]
+ if input_argument is None:
+ continue
+ if isinstance(input_argument, str):
+ input_argument = _get_audio_files(
+ data_path=pathlib.Path(input_argument).absolute()
+ )
+ if len(input_argument) < size:
+ raise ValueError(
+ f"Cannot split the input '{worker_input}' of length {len(input_argument)} to {size} workers. "
+ f"Please reduce the amount of workers for this input."
+ )
+ even_chunk_size = len(input_argument) // size
+ chunk_start = rank * even_chunk_size
+ chunk_end = (
+ (rank + 1) * even_chunk_size
+ if rank + 1 < size
+ else len(input_argument)
+ )
+ context.logger.info(
+ f"Rank #{rank}: Processing input chunk of '{worker_input}' "
+ f"from index {chunk_start} to {chunk_end}."
+ )
+ if isinstance(input_argument, list):
+ input_argument = input_argument[chunk_start:chunk_end]
+ elif isinstance(input_argument, pd.DataFrame):
+ input_argument = input_argument.iloc[chunk_start:chunk_end:, :]
+ kwargs[worker_input] = input_argument
+
+ # Set the root worker only arguments:
+ if rank == 0 and root_worker_inputs:
+ kwargs.update(root_worker_inputs)
+
+ # Run the worker:
+ output = handler(**kwargs)
+
+ # Send the output to the root rank (rank #0):
+ output = comm.gather(output, root=0)
+ if rank == 0:
+ # Join the outputs:
+ context.logger.info("Collecting data from workers to root worker.")
+ diarization_dictionary = reduce(
+ operator.ior, [dia for dia, _ in output], {}
+ )
+ errors_dictionary = reduce(operator.ior, [err for _, err in output], {})
+ return diarization_dictionary, errors_dictionary
+ return None
+
+ return wrapper
+
+ return decorator
+
+
+@open_mpi_handler(worker_inputs=["data_path"], root_worker_inputs={"verbose": True})
+def diarize(
+ data_path: Union[str, List[str]],
+ model_name: str = "pyannote/speaker-diarization-3.0",
+ access_token: str = None,
+ device: str = None,
+ speakers_labels: List[str] = None,
+ speaker_prefix: str = "speaker_",
+ separate_by_channels: bool = False,
+ minimum_speakers: int = None,
+ maximum_speakers: int = None,
+ verbose: bool = False,
+) -> Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]:
+ """
+ Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).
+ The end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ To use the `pyannote.audio` models you must pass a Huggingface token and get access to the required models. The
+ token can be passed in one of the following options:
+
+ * Use the parameter `access_token`.
+ * Set an environment variable named "HUGGING_FACE_HUB_TOKEN".
+ * If using MLRun, you can pass it as a secret named "HUGGING_FACE_HUB_TOKEN".
+
+ To get access to the models on Huggingface, visit their page. For example, to use the default diarization model set
+ in this function ("pyannote/speaker-diarization-3.0"), you need access for these two models:
+
+ * https://huggingface.co/pyannote/segmentation-3.0
+ * https://huggingface.co/pyannote/speaker-diarization-3.0
+
+ Note: To control the recognized speakers in the diarization output you can choose one of the following methods:
+
+ * For a known speakers amount, you may set speaker labels via the `speakers_labels` parameter that will be used in
+ the order of speaking in the audio (first person speaking be the first label in the list). In addition, you can do
+ diarization per channel (setting the parameter `separate_by_channels` to True). Each label will be assigned to a
+ specific channel by order (first label to channel 0, second label to channel 1 and so on). Notice, this will
+ increase runtime.
+ * For unknown speakers amount, you can set the `speaker_prefix` parameter to add a prefix for each speaker number.
+ You can also help the diarization by setting the speakers range via the `speakers_amount_range` parameter.
+
+ :param data_path: A directory of the audio files, a single file or a list of files to transcribe.
+ :param model_name: One of the official diarization model names (referred as diarization pipelines) of
+ `pyannote.audio` Huggingface page. Default: "pyannote/speaker-diarization-3.0".
+ :param access_token: An access token to pass for using the `pyannote.audio` models. If not provided, it
+ will be looking for the environment variable "HUGGING_FACE_HUB_TOKEN". If MLRun is
+ available, it will look for a secret "HUGGING_FACE_HUB_TOKEN".
+ :param device: Device to load the model. Can be one of {"cuda", "cpu"}. Default will prefer "cuda" if
+ available.
+ :param speakers_labels: Labels to use for the recognized speakers. Default: numeric labels (0, 1, ...).
+ :param separate_by_channels: If each speaker is speaking in a separate channel, you can diarize each channel and
+ combine the result into a single diarization. Each label set in the `speakers_labels`
+ parameter will be assigned to a specific channel by order.
+ :param speaker_prefix: A prefix to add for the speakers labels. This parameter is ignored if
+ `speakers_labels` is not None. Default: "speaker".
+ :param minimum_speakers: Set the minimum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param maximum_speakers: Set the maximum expected amount of speakers to be in the audio files. This parameter is
+ ignored if `speakers_labels` is not None.
+ :param verbose: Whether to present logs of a progress bar and errors. Default: True.
+
+ :returns: A tuple of:
+
+ * Speech diarization dictionary.
+ * A dictionary of errored files that were not transcribed.
+ """
+ global _LOGGER
+
+ # Get the input audio files to diarize:
+ if isinstance(data_path, str):
+ data_path = pathlib.Path(data_path).absolute()
+ audio_files = _get_audio_files(data_path=data_path)
+ else: # Should be a list of files.
+ audio_files = data_path
+
+ # Get the Huggingface access token:
+ access_token = _get_access_token(parameter=access_token)
+ if access_token is None:
+ raise ValueError(
+ "A Huggingface access token must be provided to use `pyannote.audio` models. Access token can be passed "
+ "via one of the following options:\n"
+ "* Use the parameter `access_token`.\n"
+ "* Set an environment variable named 'HUGGING_FACE_HUB_TOKEN'.\n"
+ "* If using MLRun, you can pass it as a secret named 'HUGGING_FACE_HUB_TOKEN'."
+ )
+
+ # Load the diarization pipeline:
+ pipeline = pyannote.audio.Pipeline.from_pretrained(
+ checkpoint_path=model_name, use_auth_token=access_token
+ )
+
+ # Set the device:
+ device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+ if device != "cpu":
+ pipeline.to(torch.device(device))
+
+ # Prepare the successes dataframe and errors dictionary to be returned:
+ diarizations = {}
+ errors = {}
+
+ # Prepare the diarization keyword arguments:
+ diarize_kwargs = {}
+ if speakers_labels:
+ diarize_kwargs["num_speakers"] = len(speakers_labels)
+ else:
+ if minimum_speakers:
+ diarize_kwargs["min_speakers"] = minimum_speakers
+ if maximum_speakers:
+ diarize_kwargs["max_speakers"] = maximum_speakers
+
+ # Go over the audio files and diarize:
+ for audio_file in tqdm(
+ audio_files, desc="Diarizing", unit="file", disable=not verbose
+ ):
+ try:
+ # Load audio file:
+ audio, sample_rate = torchaudio.load(uri=audio_file, channels_first=True)
+ # Get the diarization (if provided):
+ diarizations[audio_file.name] = _diarize(
+ audio=audio,
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=speakers_labels,
+ separate_by_channels=separate_by_channels,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs=diarize_kwargs,
+ )
+ except Exception as exception:
+ # Note the exception as error in the dictionary:
+ if verbose:
+ _LOGGER.warning(f"Error in file: '{audio_file.name}'")
+ errors[str(audio_file.name)] = str(exception)
+ continue
+
+ # Print the head of the produced dataframe and return:
+ if verbose:
+ _LOGGER.info(f"Done ({len(diarizations)}/{len(audio_files)})\n")
+ return diarizations, errors
+
+
+def _get_audio_files(
+ data_path: pathlib.Path,
+) -> List[pathlib.Path]:
+ # Check if the path is of a directory or a file:
+ if data_path.is_dir():
+ # Get all files inside the directory:
+ audio_files = list(data_path.glob("*.*"))
+ elif data_path.is_file():
+ audio_files = [data_path]
+ else:
+ raise ValueError(
+ f"Unrecognized data path. The parameter `data_path` must be either a directory path or a file path. "
+ f"Given: {str(data_path)} "
+ )
+
+ return audio_files
+
+
+def _get_access_token(parameter: str) -> str:
+ # If given as a parameter, return it:
+ if parameter:
+ return parameter
+
+ # Otherwise, look at the environment variable:
+ environment_variable = os.environ.get("HUGGING_FACE_HUB_TOKEN")
+ if environment_variable:
+ return environment_variable
+
+ # Lastly, try look in the set secrets in MLRun:
+ secret = None
+ try:
+ import mlrun
+
+ context = mlrun.get_or_create_ctx(name="mlrun")
+ secret = context.get_secret(key="HUGGING_FACE_HUB_TOKEN")
+ except ModuleNotFoundError:
+ pass
+
+ return secret
+
+
+def _diarize(
+ audio: torch.Tensor,
+ sample_rate: int,
+ pipeline: pyannote.audio.Pipeline,
+ speakers_labels: List[str],
+ separate_by_channels: bool,
+ speaker_prefix: str,
+ diarize_kwargs: dict,
+) -> List[Tuple[float, float, str]]:
+ # If there is no need for separation by channels, we diarize and return:
+ if not separate_by_channels:
+ # Diarize:
+ diarization: pyannote.core.Annotation = pipeline(
+ file={"waveform": audio, "sample_rate": sample_rate}, **diarize_kwargs
+ )
+ # Verify speakers labels (should not fail here as we set `num_speakers=len(speakers_labels)` when inferring
+ # through the pipeline):
+ if speakers_labels:
+ given_speakers = len(speakers_labels)
+ found_speakers = len(set(diarization.labels()))
+ if given_speakers < found_speakers:
+ raise ValueError(
+ f"Not enough `speakers_labels` were given. Got {given_speakers} labels but the diarization "
+ f"recognized {found_speakers} speakers."
+ )
+ # Return as a diarization list - a sorted list of tuples of start time, end time and a label (the default label
+ # returned is "SPEAKER_i" so we take only the index out of it):
+ return [
+ (
+ segment.start,
+ segment.end,
+ speakers_labels[int(label.split("_")[1])]
+ if speakers_labels
+ else f"{speaker_prefix}{int(label.split('_')[1])}",
+ )
+ for segment, track, label in diarization.itertracks(yield_label=True)
+ ]
+
+ # Separate to channels and diarize (we expect only one speaker per channel):
+ channel_diarizations = [
+ _diarize(
+ audio=audio[channel].unsqueeze(
+ 0
+ ), # Take channel and add a channel dimension to it.
+ sample_rate=sample_rate,
+ pipeline=pipeline,
+ speakers_labels=[
+ speakers_labels[channel]
+ ], # Take the channel's label only.
+ separate_by_channels=False,
+ speaker_prefix=speaker_prefix,
+ diarize_kwargs={"num_speakers": 1}, # Set to one speaker.
+ )
+ for channel in range(audio.shape[0])
+ ]
+
+ # Merge the channel diarizations into a single sorted list:
+ return list(heapq.merge(*channel_diarizations))
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/pyannote_audio/latest/src/function.yaml b/functions/development/pyannote_audio/latest/src/function.yaml
index 1229e0f3..2e84fbd9 100644
--- a/functions/development/pyannote_audio/latest/src/function.yaml
+++ b/functions/development/pyannote_audio/latest/src/function.yaml
@@ -2,12 +2,12 @@ kind: job
metadata:
name: pyannote-audio
tag: ''
- hash: 335752327ddd14b62222bd45faa3a88704505b66
+ hash: c45be8d7f51f0b2203155b08c307814a2cb0ac78
project: ''
labels:
author: guyl
categories:
- - Deep Learning
+ - deep-learning
- Huggingface
- Audio
spec:
@@ -35,24 +35,27 @@ spec:
- name: root_worker_inputs
type: Dict[str, Any]
default: null
- outputs:
- - default: ''
+ outputs: []
lineno: 61
+ has_varargs: false
+ has_kwargs: false
decorator:
name: decorator
doc: ''
parameters:
- name: handler
- outputs:
- - default: ''
+ outputs: []
lineno: 73
+ has_varargs: false
+ has_kwargs: false
wrapper:
name: wrapper
doc: ''
parameters: []
- outputs:
- - default: ''
+ outputs: []
lineno: 78
+ has_varargs: false
+ has_kwargs: true
diarize:
name: diarize
doc: "Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).\n\
@@ -131,8 +134,10 @@ spec:
default: false
outputs:
- doc: 'A tuple of:'
- default: ''
+ type: Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]
lineno: 139
+ has_varargs: false
+ has_kwargs: false
description: pyannote's speech diarization of audio files
default_handler: diarize
disable_auto_mount: false
diff --git a/functions/development/pyannote_audio/latest/src/item.yaml b/functions/development/pyannote_audio/latest/src/item.yaml
index 603c1a36..7133ceb4 100644
--- a/functions/development/pyannote_audio/latest/src/item.yaml
+++ b/functions/development/pyannote_audio/latest/src/item.yaml
@@ -1,8 +1,8 @@
apiVersion: v1
categories:
- - Deep Learning
- - Huggingface
- - Audio
+- deep-learning
+- Huggingface
+- Audio
description: pyannote's speech diarization of audio files
doc: ''
example: pyannote_audio.ipynb
@@ -22,9 +22,9 @@ spec:
image: mlrun/mlrun-gpu
kind: job
requirements:
- - pyannote.audio
- - pyannote.core
- - torchaudio
- - tqdm
+ - pyannote.audio
+ - pyannote.core
+ - torchaudio
+ - tqdm
url: ''
-version: 1.0.0
+version: 1.1.0
diff --git a/functions/development/pyannote_audio/latest/static/function.html b/functions/development/pyannote_audio/latest/static/function.html
index 70323934..1d34bd5c 100644
--- a/functions/development/pyannote_audio/latest/static/function.html
+++ b/functions/development/pyannote_audio/latest/static/function.html
@@ -19,12 +19,12 @@
metadata:
name: pyannote-audio
tag: ''
- hash: 335752327ddd14b62222bd45faa3a88704505b66
+ hash: c45be8d7f51f0b2203155b08c307814a2cb0ac78
project: ''
labels:
author: guyl
categories:
- - Deep Learning
+ - deep-learning
- Huggingface
- Audio
spec:
@@ -52,24 +52,27 @@
- name: root_worker_inputs
type: Dict[str, Any]
default: null
- outputs:
- - default: ''
+ outputs: []
lineno: 61
+ has_varargs: false
+ has_kwargs: false
decorator:
name: decorator
doc: ''
parameters:
- name: handler
- outputs:
- - default: ''
+ outputs: []
lineno: 73
+ has_varargs: false
+ has_kwargs: false
wrapper:
name: wrapper
doc: ''
parameters: []
- outputs:
- - default: ''
+ outputs: []
lineno: 78
+ has_varargs: false
+ has_kwargs: true
diarize:
name: diarize
doc: "Perform speech diarization on given audio files using pyannote-audio (https://github.com/pyannote/pyannote-audio).\n\
@@ -148,8 +151,10 @@
default: false
outputs:
- doc: 'A tuple of:'
- default: ''
+ type: Tuple[Dict[str, List[Tuple[float, float, str]]], Dict[str, str]]
lineno: 139
+ has_varargs: false
+ has_kwargs: false
description: pyannote's speech diarization of audio files
default_handler: diarize
disable_auto_mount: false
diff --git a/functions/development/pyannote_audio/latest/static/item.html b/functions/development/pyannote_audio/latest/static/item.html
index 5a729396..2b5611bb 100644
--- a/functions/development/pyannote_audio/latest/static/item.html
+++ b/functions/development/pyannote_audio/latest/static/item.html
@@ -17,9 +17,9 @@
apiVersion: v1
categories:
- - Deep Learning
- - Huggingface
- - Audio
+- deep-learning
+- Huggingface
+- Audio
description: pyannote's speech diarization of audio files
doc: ''
example: pyannote_audio.ipynb
@@ -39,12 +39,12 @@
image: mlrun/mlrun-gpu
kind: job
requirements:
- - pyannote.audio
- - pyannote.core
- - torchaudio
- - tqdm
+ - pyannote.audio
+ - pyannote.core
+ - torchaudio
+ - tqdm
url: ''
-version: 1.0.0
+version: 1.1.0
diff --git a/functions/development/silero_vad/1.2.0/src/assets/test_data.wav b/functions/development/silero_vad/1.2.0/src/assets/test_data.wav
new file mode 100644
index 00000000..a3a993c2
Binary files /dev/null and b/functions/development/silero_vad/1.2.0/src/assets/test_data.wav differ
diff --git a/functions/development/silero_vad/1.2.0/src/function.yaml b/functions/development/silero_vad/1.2.0/src/function.yaml
new file mode 100644
index 00000000..0b4ad422
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/src/function.yaml
@@ -0,0 +1,291 @@
+kind: job
+metadata:
+ name: silero-vad
+ tag: ''
+ hash: 61b7a70c167b7819481fdabf9350fc6fa344d2f5
+ project: ''
+ labels:
+ author: guyl
+ categories:
+ - deep-learning
+ - PyTorch
+ - Audio
+spec:
+ command: ''
+ args: []
+ image: ''
+ build:
+ functionSourceCode: # Copyright 2024 Iguazio
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from multiprocessing import Process, Queue
from pathlib import Path
from types import FunctionType
from typing import Dict, List, Tuple, Type, Union

import torch
import torchaudio
from tqdm import tqdm


class BaseTask:
    """
    A base class for a task to complete after VAD.
    """

    def __init__(self, audio_file: Path):
        """
        Initialize the base task.

        :param audio_file: The audio file assigned to the task.
        """
        # Store the audio file:
        self._audio_file = audio_file

        # Prepare the result:
        self._result = None

    @property
    def audio_file(self) -> Path:
        """
        Get the audio file of the task.

        :returns: The audio file of the task.
        """
        return self._audio_file

    def do_task(
        self, speech_timestamps: Union[List[Dict[str, int]], List[List[Dict[str, int]]]]
    ):
        """
        Do the task on the given speech timestamps. The base task will simply save the speech timestamps as the result.

        :param speech_timestamps: The speech timestamps to do the task on as outputted from the VAD.
        """
        self._result = speech_timestamps

    def get_result(self) -> Tuple[str, list]:
        """
        Get the result of the task. A tuple of the audio file name and the result.

        :returns: The result of the task.
        """
        return self._audio_file.name, self._result

    def to_tuple(self) -> Tuple[str, dict]:
        """
        Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).

        :returns: The converted task.
        """
        return self.__class__.__name__, {"audio_file": self._audio_file}


class SpeechDiarizationTask(BaseTask):
    """
    A speech diarization task. The task will diarize the VAD speech timestamps into speakers.
    """

    def __init__(self, audio_file: Path, speaker_labels: List[str]):
        """
        Initialize the speech diarization task.

        :param audio_file:     The audio file assigned to the task.
        :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be named
                               "speaker_0", "speaker_1", etc.
        """
        super().__init__(audio_file=audio_file)
        self._speaker_labels = speaker_labels

    def do_task(self, speech_timestamps: List[List[Dict[str, int]]]):
        """
        Do the task on the given speech timestamps. The task will diarize the VAD speech timestamps into speakers.

        :param speech_timestamps: The speech timestamps per channel to do the task on as outputted from the VAD.
        """
        # Get the speaker labels (set default if not given):
        speaker_labels = self._speaker_labels or [
            f"speaker_{i}" for i in range(len(speech_timestamps))
        ]

        # Diarize - organize the speech timestamps into a single list of speakers and sort it by start time:
        speech_diarization = [
            (speech_timestamp["start"], speech_timestamp["end"], speaker_label)
            for speaker_label, channel_speech_timestamps in zip(
                speaker_labels, speech_timestamps
            )
            for speech_timestamp in channel_speech_timestamps
        ]
        speech_diarization.sort()
        self._result = speech_diarization

    def to_tuple(self) -> Tuple[str, dict]:
        """
        Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).

        :returns: The converted task.
        """
        task_class, task_kwargs = super().to_tuple()
        return task_class, {**task_kwargs, "speaker_labels": self._speaker_labels}


class TaskCreator:
    """
    A task creator to create different tasks to run after the VAD.
    """

    #: A map from task class name to task class to use in `from_tuple`:
    _MAP = {
        BaseTask.__name__: BaseTask,
        SpeechDiarizationTask.__name__: SpeechDiarizationTask,
    }

    def __init__(self, task_type: Type[BaseTask], task_kwargs: dict = None):
        """
        Initialize the task creator.
        :param task_type: The task type - a `BaseTask` subclass.
        :param task_kwargs: Additional keyword arguments to pass to the to be created tasks.
        """
        self._task_type = task_type
        self._task_kwargs = task_kwargs or {}

    def create_task(self, audio_file: Path) -> BaseTask:
        """
        Create a task with the given audio file.

        :param audio_file: The audio file to assign to the task.

        :returns: The created task.
        """
        return self._task_type(audio_file=audio_file, **self._task_kwargs)

    @classmethod
    def from_tuple(cls, task_tuple: Tuple[str, dict]) -> BaseTask:
        """
        Create a task from a tuple of the audio file name and the task kwargs.

        :param task_tuple: The task tuple to create the task from.

        :returns: The created task.
        """
        task_class, task_kwargs = task_tuple
        return cls._MAP[task_class](**task_kwargs)


class VoiceActivityDetector:
    """
    A voice activity detection wrapper for the silero VAD model - https://github.com/snakers4/silero-vad.
    """

    def __init__(
        self,
        # Model loading kwargs:
        use_onnx: bool = True,
        force_onnx_cpu: bool = True,
        # Detection kwargs:
        threshold: float = 0.5,
        sampling_rate: int = 16_000,
        min_speech_duration_ms: int = 250,
        max_speech_duration_s: float = float("inf"),
        min_silence_duration_ms: int = 100,
        window_size_samples: int = 512,
        speech_pad_ms: int = 30,
        return_seconds: bool = False,
        per_channel: bool = False,
    ):
        """
        Initialize the voice activity detector.

        :param use_onnx:                Whether to use ONNX for inference. Default is True.
        :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
        :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                        probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                        this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                        most datasets.
        :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
        :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
        :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                        `max_speech_duration_s` will be split at the timestamp of the last silence that
                                        lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise,
                                        they will be split aggressively just before max_speech_duration_s.
        :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before
                                        separating it.
        :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.
                                        WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                        sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                        these may affect model performance!
        :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
        :param return_seconds:          Whether return timestamps in seconds. False means to return timestamps in
                                        samples (default - False).
        :param per_channel:             Whether to return timestamps per channel (default - False). This will run VAD
                                        on each channel separately and return a list of timestamps per channel.
        """
        # Store configurations:
        self._use_onnx = use_onnx
        self._force_onnx_cpu = force_onnx_cpu
        self._threshold = threshold
        self._sampling_rate = sampling_rate
        self._min_speech_duration_ms = min_speech_duration_ms
        self._max_speech_duration_s = max_speech_duration_s
        self._min_silence_duration_ms = min_silence_duration_ms
        self._window_size_samples = window_size_samples
        self._speech_pad_ms = speech_pad_ms
        self._return_seconds = return_seconds
        self._per_channel = per_channel

        # Prepare the model variables
        self._model: torch.Module = None
        self._get_speech_timestamps: FunctionType = None

    def load(self, force_reload: bool = True):
        """
        Load the VAD model.

        :param force_reload: Whether to force reload the model even if it was already loaded. Default is True.
        """
        model, utils = torch.hub.load(
            repo_or_dir="snakers4/silero-vad",
            model="silero_vad",
            force_reload=force_reload,
            onnx=self._use_onnx,
            force_onnx_cpu=self._force_onnx_cpu,
        )
        self._model = model
        (
            self._get_speech_timestamps,
            _,  # save_audio,
            _,  # read_audio,
            _,  # VADIterator,
            _,  # collect_chunks
        ) = utils

    def detect_voice(
        self,
        audio_file: Path,
    ) -> Union[List[Dict[str, int]], List[List[Dict[str, int]]]]:
        """
        Infer the audio through the VAD model and return the speech timestamps.

        :param audio_file: The audio file to infer.

        :returns: The speech timestamps in the audio. A list of timestamps where each timestamp is a dictionary with the
                 following keys:

                 * "start": The start sample index of the speech in the audio.
                 * "end":   The end sample index of the speech in the audio.

                 If `per_channel` is True, a list of timestamps per channel will be returned.
        """
        # Cast to a numpy array:
        audio = self._read_audio(audio_file)

        # Detect speech:
        if not self._per_channel:
            return self._get_speech_timestamps(
                audio,
                self._model,
                threshold=self._threshold,
                min_speech_duration_ms=self._min_speech_duration_ms,
                max_speech_duration_s=self._max_speech_duration_s,
                min_silence_duration_ms=self._min_silence_duration_ms,
                speech_pad_ms=self._speech_pad_ms,
                sampling_rate=self._sampling_rate,
                window_size_samples=self._window_size_samples,
                return_seconds=self._return_seconds,
            )

        # Per channel:
        speech_timestamps = []
        for channel in audio:
            speech_timestamps.append(
                self._get_speech_timestamps(
                    channel,
                    self._model,
                    threshold=self._threshold,
                    min_speech_duration_ms=self._min_speech_duration_ms,
                    max_speech_duration_s=self._max_speech_duration_s,
                    min_silence_duration_ms=self._min_silence_duration_ms,
                    speech_pad_ms=self._speech_pad_ms,
                    sampling_rate=self._sampling_rate,
                    window_size_samples=self._window_size_samples,
                    return_seconds=self._return_seconds,
                )
            )

        return speech_timestamps

    def _read_audio(
        self,
        path: Path,
    ) -> torch.Tensor:
        """
        Read the audio from the given path and return it as a tensor.

        :param path: The path to the audio file.

        :returns: The audio as a tensor.
        """
        # Read the audio:
        audio, sampling_rate = torchaudio.load(str(path))

        # Check if the audio is stereo and if so, convert it to mono (only if not per channel):
        if audio.size(0) > 1 and not self._per_channel:
            audio = audio.mean(dim=0, keepdim=True)

        # Resample the audio if needed:
        if sampling_rate != self._sampling_rate:
            transform = torchaudio.transforms.Resample(
                orig_freq=sampling_rate, new_freq=self._sampling_rate
            )
            audio = transform(audio)

        # Return the audio (squeeze if not per channel):
        return audio if self._per_channel else audio.squeeze(0)


#: The value to send into multiprocessing queues to stop the process:
_MULTIPROCESSING_STOP_MARK = "STOP"


def _multiprocessing_complete_tasks(
    vad_init_kwargs: dict, tasks_queue: Queue, results_queue: Queue
):
    """
    Complete the tasks in the given queue and put the results in the given results queue. The function will stop when
    the given tasks queue will receive the stop mark. It is aimed to be used with multiprocessing as a process.

    :param vad_init_kwargs: The VAD initialization kwargs.
    :param tasks_queue:     A queue to get the tasks from.
    :param results_queue:   A queue to put the results in.
    """
    # Initialize and load the VAD:
    vad = VoiceActivityDetector(**vad_init_kwargs)
    vad.load(force_reload=False)

    # Start listening to the tasks queue:
    while True:
        # Get the task:
        task: Tuple[str, dict] = tasks_queue.get()
        if task == _MULTIPROCESSING_STOP_MARK:
            break
        try:
            # Create the task:
            task = TaskCreator.from_tuple(task_tuple=task)
            # Run the file through the VAD:
            speech_timestamps = vad.detect_voice(audio_file=task.audio_file)
            # Complete the task:
            task.do_task(speech_timestamps=speech_timestamps)
            # Build the result:
            result = (False, task.get_result())
        except Exception as exception:
            # Build the error:
            result = (True, (task.audio_file.name, str(exception)))
        # Collect the result / error:
        results_queue.put(result)

    # Mark the end of the tasks:
    results_queue.put(_MULTIPROCESSING_STOP_MARK)


# Get the global logger:
try:
    import mlrun

    _LOGGER = mlrun.get_or_create_ctx("silero_vad").logger
except ModuleNotFoundError:
    _LOGGER = logging.getLogger()


def detect_voice(
    # Input kwargs:
    data_path: Union[str, Path, List[Union[str, Path]]],
    # Model loading kwargs:
    use_onnx: bool = True,
    force_onnx_cpu: bool = True,
    # Detection kwargs:
    threshold: float = 0.5,
    sampling_rate: int = 16_000,
    min_speech_duration_ms: int = 250,
    max_speech_duration_s: float = float("inf"),
    min_silence_duration_ms: int = 100,
    window_size_samples: int = 512,
    speech_pad_ms: int = 30,
    return_seconds: bool = False,
    per_channel: bool = False,
    # Other kwargs:
    use_multiprocessing: int = 0,
    verbose: bool = False,
):
    """
    Perform voice activity detection on given audio files using the silero VAD model -
    https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
    VAD timestamps dictionaries as value.

    For example::

        {
            "file_1.wav": [
                {"start": 0, "end": 16000},
                {"start": 16000, "end": 32000},
                {"start": 32000, "end": 48000},
                ...
            ],
            "file_2.wav": [
                {"start": 0, "end": 16000},
                {"start": 16000, "end": 32000},
                {"start": 32000, "end": 48000},
                ...
            ],
            ...
        }


    :param data_path:               The path to the audio files to diarize. Can be a path to a single file, a path to a
                                    directory or a list of paths to files.
    :param use_onnx:                Whether to use ONNX for inference. Default is True.
    :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
    :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                    probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                    this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                    most datasets.
    :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
    :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
    :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                    `max_speech_duration_s` will be split at the timestamp of the last silence that
                                    lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
                                    be split aggressively just before max_speech_duration_s.
    :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
                                    it.
    :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.

                                    WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                    sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                    these may affect model performance!
    :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
    :param return_seconds:          Whether return timestamps in seconds. False means to return timestamps in samples
                                    (default - False).
    :param per_channel:             Whether to return timestamps per channel (default - False). This will run VAD on
                                    each channel separately and return a list of timestamps per channel.
    :param use_multiprocessing:     The number of workers to use for multiprocessing. If 0, no multiprocessing will
                                    be used. Default is 0.
    :param verbose:                 Verbosity.
    """
    global _LOGGER

    # Get the input audio files to transcribe:
    if verbose:
        _LOGGER.info("Collecting audio files.")
    audio_files = _get_audio_files(data_path=data_path)
    if verbose:
        _LOGGER.info(f"Collected {len(audio_files)} audio files.")

    # Initialize the transcription pipeline:
    vad_init_kwargs = {
        "use_onnx": use_onnx,
        "force_onnx_cpu": force_onnx_cpu,
        "threshold": threshold,
        "sampling_rate": sampling_rate,
        "min_speech_duration_ms": min_speech_duration_ms,
        "max_speech_duration_s": max_speech_duration_s,
        "min_silence_duration_ms": min_silence_duration_ms,
        "window_size_samples": window_size_samples,
        "speech_pad_ms": speech_pad_ms,
        "return_seconds": return_seconds,
        "per_channel": per_channel,
    }

    # Create the task creator:
    task_creator = TaskCreator(task_type=BaseTask)

    # Run the transcription:
    if use_multiprocessing:
        results = _parallel_run(
            n_workers=use_multiprocessing,
            audio_files=audio_files,
            description="Detecting voice",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )
    else:
        results = _run(
            audio_files=audio_files,
            description="Detecting voice",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )

    # Process the results:
    return _process_results(results=results, verbose=verbose)


def diarize(
    # Input / Output kwargs:
    data_path: Union[str, Path, List[Union[str, Path]]],
    # Model loading kwargs:
    use_onnx: bool = True,
    force_onnx_cpu: bool = True,
    # Detection kwargs:
    threshold: float = 0.5,
    sampling_rate: int = 16_000,
    min_speech_duration_ms: int = 250,
    max_speech_duration_s: float = float("inf"),
    min_silence_duration_ms: int = 100,
    window_size_samples: int = 512,
    speech_pad_ms: int = 30,
    # Diarization kwargs:
    speaker_labels: List[str] = None,
    # Other kwargs:
    use_multiprocessing: int = 0,
    verbose: bool = False,
):
    """
    Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
    The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
    end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
    of tuples: (start, end, speaker_label).

    For example::

        {
            "file_1.wav": [
                (0.0, 1.0, "speaker_0"),
                (1.0, 2.0, "speaker_1"),
                (2.0, 3.0, "speaker_0"),
                ...
            ],
            "file_2.wav": [
                (0.0, 1.0, "speaker_0"),
                (1.0, 2.0, "speaker_1"),
                (2.0, 3.0, "speaker_0"),
                ...
            ],
            ...
        }


    :param data_path:               The path to the audio files to diarize. Can be a path to a single file, a path to a
                                    directory or a list of paths to files.
    :param use_onnx:                Whether to use ONNX for inference. Default is True.
    :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
    :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                    probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                    this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                    most datasets.
    :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
    :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
    :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                    `max_speech_duration_s` will be split at the timestamp of the last silence that
                                    lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
                                    be split aggressively just before max_speech_duration_s.
    :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
                                    it.
    :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.

                                    WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                    sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                    these may affect model performance!
    :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
    :param speaker_labels:          The speaker labels to use for the diarization. If not given, the speakers will be
                                    named "speaker_0", "speaker_1", etc.
    :param use_multiprocessing:     The number of workers to use for multiprocessing. If 0, no multiprocessing will
                                    be used. Default is 0.
    :param verbose:                 Verbosity.
    """
    global _LOGGER

    # Get the input audio files to transcribe:
    if verbose:
        _LOGGER.info("Collecting audio files.")
    audio_files = _get_audio_files(data_path=data_path)
    if verbose:
        _LOGGER.info(f"Collected {len(audio_files)} audio files.")

    # Initialize the transcription pipeline:
    vad_init_kwargs = {
        "use_onnx": use_onnx,
        "force_onnx_cpu": force_onnx_cpu,
        "threshold": threshold,
        "sampling_rate": sampling_rate,
        "min_speech_duration_ms": min_speech_duration_ms,
        "max_speech_duration_s": max_speech_duration_s,
        "min_silence_duration_ms": min_silence_duration_ms,
        "window_size_samples": window_size_samples,
        "speech_pad_ms": speech_pad_ms,
        "return_seconds": True,
        "per_channel": True,
    }

    # Create the task creator:
    task_creator = TaskCreator(
        task_type=SpeechDiarizationTask, task_kwargs={"speaker_labels": speaker_labels}
    )

    # Run the transcription:
    if use_multiprocessing:
        results = _parallel_run(
            n_workers=use_multiprocessing,
            audio_files=audio_files,
            description="Diarizing",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )
    else:
        results = _run(
            audio_files=audio_files,
            description="Diarizing",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )

    # Process the results:
    return _process_results(results=results, verbose=verbose)


def _get_audio_files(
    data_path: Union[Path, str, list],
) -> List[Path]:
    """
    Get the audio files from the data path. If a path to a directory is given, all files in the directory will be
    collected.

    :param data_path: The data path to collect the audio files from.

    :returns: The audio files list.
    """
    # Check if given a list of paths:
    if isinstance(data_path, list):
        audio_files = []
        for path in data_path:
            audio_files.extend(_get_audio_files(data_path=path))
        return audio_files

    # Check if given a single string path to cast it to a `pathlib.Path`:
    if isinstance(data_path, str):
        data_path = Path(data_path).absolute()

    # Check if the path is of a directory or a file:
    if data_path.is_dir():
        # Get all files inside the directory:
        audio_files = list(data_path.glob("*.*"))
    elif data_path.is_file():
        audio_files = [data_path]
    else:
        raise ValueError(
            f"Unrecognized data path. The parameter `data_path` must be a valid path to either a directory path or a "
            f"file. Given: {str(data_path)} "
        )

    return audio_files


def _run(
    audio_files: List[Path],
    description: str,
    vad_init_kwargs: dict,
    task_creator: TaskCreator,
    verbose: bool,
) -> List[Tuple[bool, Tuple[str, list]]]:
    """
    Load a VAD and use it to complete the tasks that will be created on the provided files using the given task creator.

    :param audio_files:     The audio files to use.
    :param description:     The description to use for the progress bar.
    :param vad_init_kwargs: The VAD initialization keyword arguments.
    :param task_creator:    The task creator to use to create the tasks.
    :param verbose:         Verbosity.

    :returns: The collected results.
    """
    # Load the VAD:
    vad = VoiceActivityDetector(**vad_init_kwargs)
    if verbose:
        _LOGGER.info(f"Loading the VAD model.")
    vad.load()
    if verbose:
        _LOGGER.info("VAD model loaded.")

    # Run the VAD on the audio files and collect the results:
    results = []
    for audio_file in tqdm(
        audio_files,
        desc=description,
        unit="file",
        total=len(audio_files),
        disable=not verbose,
    ):
        try:
            # Create the task:
            task = task_creator.create_task(audio_file=audio_file)
            # Run the file through the VAD:
            speech_timestamps = vad.detect_voice(audio_file=audio_file)
            # Complete the task:
            task.do_task(speech_timestamps=speech_timestamps)
            # Collect the result:
            results.append((False, task.get_result()))
        except Exception as exception:
            # Collect the error:
            results.append((True, (audio_file.name, str(exception))))

    return results


def _parallel_run(
    n_workers: int,
    audio_files: List[Path],
    description: str,
    vad_init_kwargs: dict,
    task_creator: TaskCreator,
    verbose: bool,
) -> List[Tuple[bool, Tuple[str, list]]]:
    """
    Run multiple VAD workers with multiprocessing to complete the tasks that will be created on the provided files using
    the given task creator.

    :param n_workers:       The number of workers to use.
    :param audio_files:     The audio files to use.
    :param description:     The description to use for the progress bar.
    :param vad_init_kwargs: The VAD initialization keyword arguments.
    :param task_creator:    The task creator to use to create the tasks.
    :param verbose:         Verbosity.

    :returns: The collected results.
    """
    # Load the VAD (download once, and it will be loaded then per process later on):
    if verbose:
        _LOGGER.info(f"Loading the VAD model.")
    vad = VoiceActivityDetector(**vad_init_kwargs)
    vad.load()
    if verbose:
        _LOGGER.info("VAD model loaded.")

    # Check the number of workers:
    if n_workers > len(audio_files):
        _LOGGER.warning(
            f"The number of workers ({n_workers}) is larger than the number of audio files ({len(audio_files)}). "
            f"Setting the number of workers to {len(audio_files)}."
        )
        n_workers = len(audio_files)

    # Initialize the multiprocessing queues:
    tasks_queue = Queue()
    results_queue = Queue()

    # Initialize the multiprocessing processes:
    task_completion_processes = [
        Process(
            target=_multiprocessing_complete_tasks,
            kwargs={
                "vad_init_kwargs": vad_init_kwargs,
                "tasks_queue": tasks_queue,
                "results_queue": results_queue,
            },
        )
        for _ in range(n_workers)
    ]

    # Start the multiprocessing processes:
    for p in task_completion_processes:
        p.start()

    # Put the tasks in the queue:
    for audio_file in audio_files:
        tasks_queue.put(task_creator.create_task(audio_file=audio_file).to_tuple())

    # Put the stop marks in the queue:
    for _ in range(n_workers):
        tasks_queue.put(_MULTIPROCESSING_STOP_MARK)

    # Collect the results:
    results = []
    stop_marks_counter = 0
    with tqdm(
        desc=description,
        unit="file",
        total=len(audio_files),
        disable=not verbose,
    ) as progressbar:
        while True:
            # Get a result from the queue:
            result: Tuple[bool, Tuple[str, list]] = results_queue.get()
            if result == _MULTIPROCESSING_STOP_MARK:
                stop_marks_counter += 1
                if stop_marks_counter == n_workers:
                    break
            else:
                # Collect the result:
                results.append(result)
                progressbar.update(1)

    # Wait for the processes to finish:
    for p in task_completion_processes:
        p.join()

    return results


def _process_results(
    results: List[Tuple[bool, Tuple[str, list]]], verbose: bool
) -> Tuple[dict, dict]:
    """
    Process the results of the tasks.

    :param results: The results to process.
    :param verbose: Verbosity.

    :returns: The processed results as a tuple of successes and errors.
    """
    if verbose:
        _LOGGER.info("Summarizing the results.")
    successes = {}
    errors = {}
    for is_error, result in results:
        if is_error:
            errors[result[0]] = result[1]
        else:
            successes[result[0]] = result[1]
    if verbose:
        _LOGGER.info(f"Done ({len(successes)}/{len(successes) + len(errors)})\n")

    return successes, errors

+ base_image: mlrun/mlrun
+ commands: []
+ code_origin: ''
+ origin_filename: ''
+ requirements:
+ - torch
+ - torchaudio
+ - tqdm
+ - onnxruntime
+ entry_points:
+ audio_file:
+ name: audio_file
+ doc: Get the audio file of the task.
+ parameters:
+ - name: self
+ outputs:
+ - doc: The audio file of the task.
+ type: Path
+ lineno: 43
+ has_varargs: false
+ has_kwargs: false
+ do_task:
+ name: do_task
+ doc: Do the task on the given speech timestamps. The task will diarize the VAD
+ speech timestamps into speakers.
+ parameters:
+ - name: self
+ - name: speech_timestamps
+ type: List[List[Dict[str, int]]]
+ doc: The speech timestamps per channel to do the task on as outputted from
+ the VAD.
+ outputs: []
+ lineno: 94
+ has_varargs: false
+ has_kwargs: false
+ get_result:
+ name: get_result
+ doc: Get the result of the task. A tuple of the audio file name and the result.
+ parameters:
+ - name: self
+ outputs:
+ - doc: The result of the task.
+ type: Tuple[str, list]
+ lineno: 61
+ has_varargs: false
+ has_kwargs: false
+ to_tuple:
+ name: to_tuple
+ doc: Convert the task to a tuple to reconstruct it later (used for multiprocessing
+ to pass in queue).
+ parameters:
+ - name: self
+ outputs:
+ - doc: The converted task.
+ type: Tuple[str, dict]
+ lineno: 116
+ has_varargs: false
+ has_kwargs: false
+ create_task:
+ name: create_task
+ doc: Create a task with the given audio file.
+ parameters:
+ - name: self
+ - name: audio_file
+ type: Path
+ doc: The audio file to assign to the task.
+ outputs:
+ - doc: The created task.
+ type: BaseTask
+ lineno: 146
+ has_varargs: false
+ has_kwargs: false
+ from_tuple:
+ name: from_tuple
+ doc: Create a task from a tuple of the audio file name and the task kwargs.
+ parameters:
+ - name: cls
+ - name: task_tuple
+ type: Tuple[str, dict]
+ doc: The task tuple to create the task from.
+ outputs:
+ - doc: The created task.
+ type: BaseTask
+ lineno: 157
+ has_varargs: false
+ has_kwargs: false
+ load:
+ name: load
+ doc: Load the VAD model.
+ parameters:
+ - name: self
+ - name: force_reload
+ type: bool
+ doc: Whether to force reload the model even if it was already loaded. Default
+ is True.
+ default: true
+ outputs: []
+ lineno: 234
+ has_varargs: false
+ has_kwargs: false
+ detect_voice:
+ name: detect_voice
+ doc: "Perform voice activity detection on given audio files using the silero\
+ \ VAD model -\nhttps://github.com/snakers4/silero-vad. The end result is a\
+ \ dictionary with the file names as keys and their\nVAD timestamps dictionaries\
+ \ as value.\n\nFor example::\n\n {\n \"file_1.wav\": [\n \
+ \ {\"start\": 0, \"end\": 16000},\n {\"start\": 16000, \"end\"\
+ : 32000},\n {\"start\": 32000, \"end\": 48000},\n ...\n\
+ \ ],\n \"file_2.wav\": [\n {\"start\": 0, \"end\"\
+ : 16000},\n {\"start\": 16000, \"end\": 32000},\n {\"\
+ start\": 32000, \"end\": 48000},\n ...\n ],\n ...\n\
+ \ }"
+ parameters:
+ - name: data_path
+ type: Union[str, Path, List[Union[str, Path]]]
+ doc: The path to the audio files to diarize. Can be a path to a single file,
+ a path to a directory or a list of paths to files.
+ - name: use_onnx
+ type: bool
+ doc: Whether to use ONNX for inference. Default is True.
+ default: true
+ - name: force_onnx_cpu
+ type: bool
+ doc: Whether to force ONNX to use CPU for inference. Default is True.
+ default: true
+ - name: threshold
+ type: float
+ doc: Speech threshold. Silero VAD outputs speech probabilities for each audio
+ chunk, probabilities ABOVE this value are considered as SPEECH. It is better
+ to tune this parameter for each dataset separately, but "lazy" 0.5 is pretty
+ good for most datasets.
+ default: 0.5
+ - name: sampling_rate
+ type: int
+ doc: Currently, silero VAD models support 8000 and 16000 sample rates.
+ default: 16000
+ - name: min_speech_duration_ms
+ type: int
+ doc: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ default: 250
+ - name: max_speech_duration_s
+ type: float
+ doc: Maximum duration of speech chunks in seconds. Chunks longer than `max_speech_duration_s`
+ will be split at the timestamp of the last silence that lasts more than
+ 100ms (if any), to prevent aggressive cutting. Otherwise, they will be split
+ aggressively just before max_speech_duration_s.
+ default: float('inf')
+ - name: min_silence_duration_ms
+ type: int
+ doc: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ default: 100
+ - name: window_size_samples
+ type: int
+ doc: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ default: 512
+ - name: speech_pad_ms
+ type: int
+ doc: Final speech chunks are padded by speech_pad_ms each side.
+ default: 30
+ - name: return_seconds
+ type: bool
+ doc: Whether return timestamps in seconds. False means to return timestamps
+ in samples (default - False).
+ default: false
+ - name: per_channel
+ type: bool
+ doc: Whether to return timestamps per channel (default - False). This will
+ run VAD on each channel separately and return a list of timestamps per channel.
+ default: false
+ - name: use_multiprocessing
+ type: int
+ doc: The number of workers to use for multiprocessing. If 0, no multiprocessing
+ will be used. Default is 0.
+ default: 0
+ - name: verbose
+ type: bool
+ doc: Verbosity.
+ default: false
+ outputs: []
+ lineno: 393
+ has_varargs: false
+ has_kwargs: false
+ diarize:
+ name: diarize
+ doc: "Perform speech diarization on given audio files using the silero VAD model\
+ \ - https://github.com/snakers4/silero-vad.\nThe speech diarization is performed\
+ \ per channel so that each channel in the audio belong to a different speaker.\
+ \ The\nend result is a dictionary with the file names as keys and their diarization\
+ \ as value. A diarization is a list\nof tuples: (start, end, speaker_label).\n\
+ \nFor example::\n\n {\n \"file_1.wav\": [\n (0.0, 1.0,\
+ \ \"speaker_0\"),\n (1.0, 2.0, \"speaker_1\"),\n (2.0,\
+ \ 3.0, \"speaker_0\"),\n ...\n ],\n \"file_2.wav\"\
+ : [\n (0.0, 1.0, \"speaker_0\"),\n (1.0, 2.0, \"speaker_1\"\
+ ),\n (2.0, 3.0, \"speaker_0\"),\n ...\n ],\n\
+ \ ...\n }"
+ parameters:
+ - name: data_path
+ type: Union[str, Path, List[Union[str, Path]]]
+ doc: The path to the audio files to diarize. Can be a path to a single file,
+ a path to a directory or a list of paths to files.
+ - name: use_onnx
+ type: bool
+ doc: Whether to use ONNX for inference. Default is True.
+ default: true
+ - name: force_onnx_cpu
+ type: bool
+ doc: Whether to force ONNX to use CPU for inference. Default is True.
+ default: true
+ - name: threshold
+ type: float
+ doc: Speech threshold. Silero VAD outputs speech probabilities for each audio
+ chunk, probabilities ABOVE this value are considered as SPEECH. It is better
+ to tune this parameter for each dataset separately, but "lazy" 0.5 is pretty
+ good for most datasets.
+ default: 0.5
+ - name: sampling_rate
+ type: int
+ doc: Currently, silero VAD models support 8000 and 16000 sample rates.
+ default: 16000
+ - name: min_speech_duration_ms
+ type: int
+ doc: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ default: 250
+ - name: max_speech_duration_s
+ type: float
+ doc: Maximum duration of speech chunks in seconds. Chunks longer than `max_speech_duration_s`
+ will be split at the timestamp of the last silence that lasts more than
+ 100ms (if any), to prevent aggressive cutting. Otherwise, they will be split
+ aggressively just before max_speech_duration_s.
+ default: float('inf')
+ - name: min_silence_duration_ms
+ type: int
+ doc: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ default: 100
+ - name: window_size_samples
+ type: int
+ doc: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ default: 512
+ - name: speech_pad_ms
+ type: int
+ doc: Final speech chunks are padded by speech_pad_ms each side.
+ default: 30
+ - name: speaker_labels
+ type: List[str]
+ doc: The speaker labels to use for the diarization. If not given, the speakers
+ will be named "speaker_0", "speaker_1", etc.
+ default: null
+ - name: use_multiprocessing
+ type: int
+ doc: The number of workers to use for multiprocessing. If 0, no multiprocessing
+ will be used. Default is 0.
+ default: 0
+ - name: verbose
+ type: bool
+ doc: Verbosity.
+ default: false
+ outputs: []
+ lineno: 517
+ has_varargs: false
+ has_kwargs: false
+ description: Silero VAD (Voice Activity Detection) functions.
+ default_handler: detect_voice
+ disable_auto_mount: false
+ clone_target_dir: ''
+ env: []
+ priority_class_name: ''
+ preemption_mode: prevent
+ affinity: null
+ tolerations: null
+ security_context: {}
+verbose: false
diff --git a/functions/development/silero_vad/1.2.0/src/item.yaml b/functions/development/silero_vad/1.2.0/src/item.yaml
new file mode 100644
index 00000000..17c8eb62
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/src/item.yaml
@@ -0,0 +1,30 @@
+apiVersion: v1
+categories:
+- deep-learning
+- PyTorch
+- Audio
+description: Silero VAD (Voice Activity Detection) functions.
+doc: ''
+example: silero_vad.ipynb
+generationDate: 2023-12-03:14-30
+hidden: false
+icon: ''
+labels:
+ author: guyl
+maintainers: []
+marketplaceType: ''
+mlrunVersion: 1.5.2
+name: silero_vad
+platformVersion: 3.5.3
+spec:
+ filename: silero_vad.py
+ handler: detect_voice
+ image: mlrun/mlrun
+ kind: job
+ requirements:
+ - torch
+ - torchaudio
+ - tqdm
+ - onnxruntime
+url: ''
+version: 1.2.0
diff --git a/functions/development/silero_vad/1.2.0/src/silero_vad.ipynb b/functions/development/silero_vad/1.2.0/src/silero_vad.ipynb
new file mode 100644
index 00000000..29cd7437
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/src/silero_vad.ipynb
@@ -0,0 +1,35 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "initial_id",
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/functions/development/silero_vad/1.2.0/src/silero_vad.py b/functions/development/silero_vad/1.2.0/src/silero_vad.py
new file mode 100644
index 00000000..a477d4ec
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/src/silero_vad.py
@@ -0,0 +1,847 @@
+# Copyright 2024 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+from multiprocessing import Process, Queue
+from pathlib import Path
+from types import FunctionType
+from typing import Dict, List, Tuple, Type, Union
+
+import torch
+import torchaudio
+from tqdm import tqdm
+
+
+class BaseTask:
+ """
+ A base class for a task to complete after VAD.
+ """
+
+ def __init__(self, audio_file: Path):
+ """
+ Initialize the base task.
+
+ :param audio_file: The audio file assigned to the task.
+ """
+ # Store the audio file:
+ self._audio_file = audio_file
+
+ # Prepare the result:
+ self._result = None
+
+ @property
+ def audio_file(self) -> Path:
+ """
+ Get the audio file of the task.
+
+ :returns: The audio file of the task.
+ """
+ return self._audio_file
+
+ def do_task(
+ self, speech_timestamps: Union[List[Dict[str, int]], List[List[Dict[str, int]]]]
+ ):
+ """
+ Do the task on the given speech timestamps. The base task will simply save the speech timestamps as the result.
+
+ :param speech_timestamps: The speech timestamps to do the task on as outputted from the VAD.
+ """
+ self._result = speech_timestamps
+
+ def get_result(self) -> Tuple[str, list]:
+ """
+ Get the result of the task. A tuple of the audio file name and the result.
+
+ :returns: The result of the task.
+ """
+ return self._audio_file.name, self._result
+
+ def to_tuple(self) -> Tuple[str, dict]:
+ """
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ return self.__class__.__name__, {"audio_file": self._audio_file}
+
+
+class SpeechDiarizationTask(BaseTask):
+ """
+ A speech diarization task. The task will diarize the VAD speech timestamps into speakers.
+ """
+
+ def __init__(self, audio_file: Path, speaker_labels: List[str]):
+ """
+ Initialize the speech diarization task.
+
+ :param audio_file: The audio file assigned to the task.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be named
+ "speaker_0", "speaker_1", etc.
+ """
+ super().__init__(audio_file=audio_file)
+ self._speaker_labels = speaker_labels
+
+ def do_task(self, speech_timestamps: List[List[Dict[str, int]]]):
+ """
+ Do the task on the given speech timestamps. The task will diarize the VAD speech timestamps into speakers.
+
+ :param speech_timestamps: The speech timestamps per channel to do the task on as outputted from the VAD.
+ """
+ # Get the speaker labels (set default if not given):
+ speaker_labels = self._speaker_labels or [
+ f"speaker_{i}" for i in range(len(speech_timestamps))
+ ]
+
+ # Diarize - organize the speech timestamps into a single list of speakers and sort it by start time:
+ speech_diarization = [
+ (speech_timestamp["start"], speech_timestamp["end"], speaker_label)
+ for speaker_label, channel_speech_timestamps in zip(
+ speaker_labels, speech_timestamps
+ )
+ for speech_timestamp in channel_speech_timestamps
+ ]
+ speech_diarization.sort()
+ self._result = speech_diarization
+
+ def to_tuple(self) -> Tuple[str, dict]:
+ """
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ task_class, task_kwargs = super().to_tuple()
+ return task_class, {**task_kwargs, "speaker_labels": self._speaker_labels}
+
+
+class TaskCreator:
+ """
+ A task creator to create different tasks to run after the VAD.
+ """
+
+ #: A map from task class name to task class to use in `from_tuple`:
+ _MAP = {
+ BaseTask.__name__: BaseTask,
+ SpeechDiarizationTask.__name__: SpeechDiarizationTask,
+ }
+
+ def __init__(self, task_type: Type[BaseTask], task_kwargs: dict = None):
+ """
+ Initialize the task creator.
+ :param task_type: The task type - a `BaseTask` subclass.
+ :param task_kwargs: Additional keyword arguments to pass to the to be created tasks.
+ """
+ self._task_type = task_type
+ self._task_kwargs = task_kwargs or {}
+
+ def create_task(self, audio_file: Path) -> BaseTask:
+ """
+ Create a task with the given audio file.
+
+ :param audio_file: The audio file to assign to the task.
+
+ :returns: The created task.
+ """
+ return self._task_type(audio_file=audio_file, **self._task_kwargs)
+
+ @classmethod
+ def from_tuple(cls, task_tuple: Tuple[str, dict]) -> BaseTask:
+ """
+ Create a task from a tuple of the audio file name and the task kwargs.
+
+ :param task_tuple: The task tuple to create the task from.
+
+ :returns: The created task.
+ """
+ task_class, task_kwargs = task_tuple
+ return cls._MAP[task_class](**task_kwargs)
+
+
+class VoiceActivityDetector:
+ """
+ A voice activity detection wrapper for the silero VAD model - https://github.com/snakers4/silero-vad.
+ """
+
+ def __init__(
+ self,
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ return_seconds: bool = False,
+ per_channel: bool = False,
+ ):
+ """
+ Initialize the voice activity detector.
+
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise,
+ they will be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in
+ samples (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD
+ on each channel separately and return a list of timestamps per channel.
+ """
+ # Store configurations:
+ self._use_onnx = use_onnx
+ self._force_onnx_cpu = force_onnx_cpu
+ self._threshold = threshold
+ self._sampling_rate = sampling_rate
+ self._min_speech_duration_ms = min_speech_duration_ms
+ self._max_speech_duration_s = max_speech_duration_s
+ self._min_silence_duration_ms = min_silence_duration_ms
+ self._window_size_samples = window_size_samples
+ self._speech_pad_ms = speech_pad_ms
+ self._return_seconds = return_seconds
+ self._per_channel = per_channel
+
+ # Prepare the model variables
+ self._model: torch.Module = None
+ self._get_speech_timestamps: FunctionType = None
+
+ def load(self, force_reload: bool = True):
+ """
+ Load the VAD model.
+
+ :param force_reload: Whether to force reload the model even if it was already loaded. Default is True.
+ """
+ model, utils = torch.hub.load(
+ repo_or_dir="snakers4/silero-vad",
+ model="silero_vad",
+ force_reload=force_reload,
+ onnx=self._use_onnx,
+ force_onnx_cpu=self._force_onnx_cpu,
+ )
+ self._model = model
+ (
+ self._get_speech_timestamps,
+ _, # save_audio,
+ _, # read_audio,
+ _, # VADIterator,
+ _, # collect_chunks
+ ) = utils
+
+ def detect_voice(
+ self,
+ audio_file: Path,
+ ) -> Union[List[Dict[str, int]], List[List[Dict[str, int]]]]:
+ """
+ Infer the audio through the VAD model and return the speech timestamps.
+
+ :param audio_file: The audio file to infer.
+
+ :returns: The speech timestamps in the audio. A list of timestamps where each timestamp is a dictionary with the
+ following keys:
+
+ * "start": The start sample index of the speech in the audio.
+ * "end": The end sample index of the speech in the audio.
+
+ If `per_channel` is True, a list of timestamps per channel will be returned.
+ """
+ # Cast to a numpy array:
+ audio = self._read_audio(audio_file)
+
+ # Detect speech:
+ if not self._per_channel:
+ return self._get_speech_timestamps(
+ audio,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+
+ # Per channel:
+ speech_timestamps = []
+ for channel in audio:
+ speech_timestamps.append(
+ self._get_speech_timestamps(
+ channel,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+ )
+
+ return speech_timestamps
+
+ def _read_audio(
+ self,
+ path: Path,
+ ) -> torch.Tensor:
+ """
+ Read the audio from the given path and return it as a tensor.
+
+ :param path: The path to the audio file.
+
+ :returns: The audio as a tensor.
+ """
+ # Read the audio:
+ audio, sampling_rate = torchaudio.load(str(path))
+
+ # Check if the audio is stereo and if so, convert it to mono (only if not per channel):
+ if audio.size(0) > 1 and not self._per_channel:
+ audio = audio.mean(dim=0, keepdim=True)
+
+ # Resample the audio if needed:
+ if sampling_rate != self._sampling_rate:
+ transform = torchaudio.transforms.Resample(
+ orig_freq=sampling_rate, new_freq=self._sampling_rate
+ )
+ audio = transform(audio)
+
+ # Return the audio (squeeze if not per channel):
+ return audio if self._per_channel else audio.squeeze(0)
+
+
+#: The value to send into multiprocessing queues to stop the process:
+_MULTIPROCESSING_STOP_MARK = "STOP"
+
+
+def _multiprocessing_complete_tasks(
+ vad_init_kwargs: dict, tasks_queue: Queue, results_queue: Queue
+):
+ """
+ Complete the tasks in the given queue and put the results in the given results queue. The function will stop when
+ the given tasks queue will receive the stop mark. It is aimed to be used with multiprocessing as a process.
+
+ :param vad_init_kwargs: The VAD initialization kwargs.
+ :param tasks_queue: A queue to get the tasks from.
+ :param results_queue: A queue to put the results in.
+ """
+ # Initialize and load the VAD:
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ vad.load(force_reload=False)
+
+ # Start listening to the tasks queue:
+ while True:
+ # Get the task:
+ task: Tuple[str, dict] = tasks_queue.get()
+ if task == _MULTIPROCESSING_STOP_MARK:
+ break
+ try:
+ # Create the task:
+ task = TaskCreator.from_tuple(task_tuple=task)
+ # Run the file through the VAD:
+ speech_timestamps = vad.detect_voice(audio_file=task.audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Build the result:
+ result = (False, task.get_result())
+ except Exception as exception:
+ # Build the error:
+ result = (True, (task.audio_file.name, str(exception)))
+ # Collect the result / error:
+ results_queue.put(result)
+
+ # Mark the end of the tasks:
+ results_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+
+# Get the global logger:
+try:
+ import mlrun
+
+ _LOGGER = mlrun.get_or_create_ctx("silero_vad").logger
+except ModuleNotFoundError:
+ _LOGGER = logging.getLogger()
+
+
+def detect_voice(
+ # Input kwargs:
+ data_path: Union[str, Path, List[Union[str, Path]]],
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ return_seconds: bool = False,
+ per_channel: bool = False,
+ # Other kwargs:
+ use_multiprocessing: int = 0,
+ verbose: bool = False,
+):
+ """
+ Perform voice activity detection on given audio files using the silero VAD model -
+ https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
+ VAD timestamps dictionaries as value.
+
+ For example::
+
+ {
+ "file_1.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ "file_2.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in samples
+ (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD on
+ each channel separately and return a list of timestamps per channel.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global _LOGGER
+
+ # Get the input audio files to transcribe:
+ if verbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files = _get_audio_files(data_path=data_path)
+ if verbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs = {
+ "use_onnx": use_onnx,
+ "force_onnx_cpu": force_onnx_cpu,
+ "threshold": threshold,
+ "sampling_rate": sampling_rate,
+ "min_speech_duration_ms": min_speech_duration_ms,
+ "max_speech_duration_s": max_speech_duration_s,
+ "min_silence_duration_ms": min_silence_duration_ms,
+ "window_size_samples": window_size_samples,
+ "speech_pad_ms": speech_pad_ms,
+ "return_seconds": return_seconds,
+ "per_channel": per_channel,
+ }
+
+ # Create the task creator:
+ task_creator = TaskCreator(task_type=BaseTask)
+
+ # Run the transcription:
+ if use_multiprocessing:
+ results = _parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results = _run(
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return _process_results(results=results, verbose=verbose)
+
+
+def diarize(
+ # Input / Output kwargs:
+ data_path: Union[str, Path, List[Union[str, Path]]],
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ # Diarization kwargs:
+ speaker_labels: List[str] = None,
+ # Other kwargs:
+ use_multiprocessing: int = 0,
+ verbose: bool = False,
+):
+ """
+ Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
+ The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
+ end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ For example::
+
+ {
+ "file_1.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ "file_2.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be
+ named "speaker_0", "speaker_1", etc.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global _LOGGER
+
+ # Get the input audio files to transcribe:
+ if verbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files = _get_audio_files(data_path=data_path)
+ if verbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs = {
+ "use_onnx": use_onnx,
+ "force_onnx_cpu": force_onnx_cpu,
+ "threshold": threshold,
+ "sampling_rate": sampling_rate,
+ "min_speech_duration_ms": min_speech_duration_ms,
+ "max_speech_duration_s": max_speech_duration_s,
+ "min_silence_duration_ms": min_silence_duration_ms,
+ "window_size_samples": window_size_samples,
+ "speech_pad_ms": speech_pad_ms,
+ "return_seconds": True,
+ "per_channel": True,
+ }
+
+ # Create the task creator:
+ task_creator = TaskCreator(
+ task_type=SpeechDiarizationTask, task_kwargs={"speaker_labels": speaker_labels}
+ )
+
+ # Run the transcription:
+ if use_multiprocessing:
+ results = _parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results = _run(
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return _process_results(results=results, verbose=verbose)
+
+
+def _get_audio_files(
+ data_path: Union[Path, str, list],
+) -> List[Path]:
+ """
+ Get the audio files from the data path. If a path to a directory is given, all files in the directory will be
+ collected.
+
+ :param data_path: The data path to collect the audio files from.
+
+ :returns: The audio files list.
+ """
+ # Check if given a list of paths:
+ if isinstance(data_path, list):
+ audio_files = []
+ for path in data_path:
+ audio_files.extend(_get_audio_files(data_path=path))
+ return audio_files
+
+ # Check if given a single string path to cast it to a `pathlib.Path`:
+ if isinstance(data_path, str):
+ data_path = Path(data_path).absolute()
+
+ # Check if the path is of a directory or a file:
+ if data_path.is_dir():
+ # Get all files inside the directory:
+ audio_files = list(data_path.glob("*.*"))
+ elif data_path.is_file():
+ audio_files = [data_path]
+ else:
+ raise ValueError(
+ f"Unrecognized data path. The parameter `data_path` must be a valid path to either a directory path or a "
+ f"file. Given: {str(data_path)} "
+ )
+
+ return audio_files
+
+
+def _run(
+ audio_files: List[Path],
+ description: str,
+ vad_init_kwargs: dict,
+ task_creator: TaskCreator,
+ verbose: bool,
+) -> List[Tuple[bool, Tuple[str, list]]]:
+ """
+ Load a VAD and use it to complete the tasks that will be created on the provided files using the given task creator.
+
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD:
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ if verbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad.load()
+ if verbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Run the VAD on the audio files and collect the results:
+ results = []
+ for audio_file in tqdm(
+ audio_files,
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=not verbose,
+ ):
+ try:
+ # Create the task:
+ task = task_creator.create_task(audio_file=audio_file)
+ # Run the file through the VAD:
+ speech_timestamps = vad.detect_voice(audio_file=audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Collect the result:
+ results.append((False, task.get_result()))
+ except Exception as exception:
+ # Collect the error:
+ results.append((True, (audio_file.name, str(exception))))
+
+ return results
+
+
+def _parallel_run(
+ n_workers: int,
+ audio_files: List[Path],
+ description: str,
+ vad_init_kwargs: dict,
+ task_creator: TaskCreator,
+ verbose: bool,
+) -> List[Tuple[bool, Tuple[str, list]]]:
+ """
+ Run multiple VAD workers with multiprocessing to complete the tasks that will be created on the provided files using
+ the given task creator.
+
+ :param n_workers: The number of workers to use.
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD (download once, and it will be loaded then per process later on):
+ if verbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ vad.load()
+ if verbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Check the number of workers:
+ if n_workers > len(audio_files):
+ _LOGGER.warning(
+ f"The number of workers ({n_workers}) is larger than the number of audio files ({len(audio_files)}). "
+ f"Setting the number of workers to {len(audio_files)}."
+ )
+ n_workers = len(audio_files)
+
+ # Initialize the multiprocessing queues:
+ tasks_queue = Queue()
+ results_queue = Queue()
+
+ # Initialize the multiprocessing processes:
+ task_completion_processes = [
+ Process(
+ target=_multiprocessing_complete_tasks,
+ kwargs={
+ "vad_init_kwargs": vad_init_kwargs,
+ "tasks_queue": tasks_queue,
+ "results_queue": results_queue,
+ },
+ )
+ for _ in range(n_workers)
+ ]
+
+ # Start the multiprocessing processes:
+ for p in task_completion_processes:
+ p.start()
+
+ # Put the tasks in the queue:
+ for audio_file in audio_files:
+ tasks_queue.put(task_creator.create_task(audio_file=audio_file).to_tuple())
+
+ # Put the stop marks in the queue:
+ for _ in range(n_workers):
+ tasks_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+ # Collect the results:
+ results = []
+ stop_marks_counter = 0
+ with tqdm(
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=not verbose,
+ ) as progressbar:
+ while True:
+ # Get a result from the queue:
+ result: Tuple[bool, Tuple[str, list]] = results_queue.get()
+ if result == _MULTIPROCESSING_STOP_MARK:
+ stop_marks_counter += 1
+ if stop_marks_counter == n_workers:
+ break
+ else:
+ # Collect the result:
+ results.append(result)
+ progressbar.update(1)
+
+ # Wait for the processes to finish:
+ for p in task_completion_processes:
+ p.join()
+
+ return results
+
+
+def _process_results(
+ results: List[Tuple[bool, Tuple[str, list]]], verbose: bool
+) -> Tuple[dict, dict]:
+ """
+ Process the results of the tasks.
+
+ :param results: The results to process.
+ :param verbose: Verbosity.
+
+ :returns: The processed results as a tuple of successes and errors.
+ """
+ if verbose:
+ _LOGGER.info("Summarizing the results.")
+ successes = {}
+ errors = {}
+ for is_error, result in results:
+ if is_error:
+ errors[result[0]] = result[1]
+ else:
+ successes[result[0]] = result[1]
+ if verbose:
+ _LOGGER.info(f"Done ({len(successes)}/{len(successes) + len(errors)})\n")
+
+ return successes, errors
diff --git a/functions/development/silero_vad/1.2.0/src/test_silero_vad.py b/functions/development/silero_vad/1.2.0/src/test_silero_vad.py
new file mode 100644
index 00000000..d46471a5
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/src/test_silero_vad.py
@@ -0,0 +1,44 @@
+import os
+import tempfile
+
+import mlrun
+import pytest
+
+
+@pytest.fixture()
+def setup_test():
+ with tempfile.TemporaryDirectory() as artifact_path:
+ project = mlrun.get_or_create_project(name="default", context=artifact_path)
+ func = project.set_function(
+ func=os.path.abspath("./function.yaml"),
+ name="silero-vad",
+ image="mlrun/mlrun",
+ )
+ yield func, artifact_path
+
+
+def test_detect_voice(setup_test):
+ silero_vad_function, artifact_path = setup_test
+ run = silero_vad_function.run(
+ handler="detect_voice",
+ inputs={"data_path": "./assets"},
+ returns=["vad_outputs: file", "errors: file"],
+ artifact_path=artifact_path,
+ local=True,
+ )
+ assert run.outputs["vad_outputs"]
+
+
+def test_diarize(setup_test):
+ silero_vad_function, artifact_path = setup_test
+ run = silero_vad_function.run(
+ handler="diarize",
+ inputs={"data_path": "./assets"},
+ params={
+ "speakers_labels": ["Agent", "Client"],
+ },
+ returns=["speech_diarization: file", "errors: file"],
+ artifact_path=artifact_path,
+ local=True,
+ )
+ assert run.outputs["speech_diarization"]
diff --git a/functions/development/silero_vad/1.2.0/static/documentation.html b/functions/development/silero_vad/1.2.0/static/documentation.html
new file mode 100644
index 00000000..d9cd1445
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/static/documentation.html
@@ -0,0 +1,481 @@
+
+
+
+
+
+
+
+silero_vad package
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Perform voice activity detection on given audio files using the silero VAD model -
+https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
+VAD timestamps dictionaries as value.
data_path – The path to the audio files to diarize. Can be a path to a single file, a path to a
+directory or a list of paths to files.
+
use_onnx – Whether to use ONNX for inference. Default is True.
+
force_onnx_cpu – Whether to force ONNX to use CPU for inference. Default is True.
+
threshold – Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+probabilities ABOVE this value are considered as SPEECH. It is better to tune
+this parameter for each dataset separately, but “lazy” 0.5 is pretty good for
+most datasets.
+
sampling_rate – Currently, silero VAD models support 8000 and 16000 sample rates.
+
min_speech_duration_ms – Final speech chunks shorter min_speech_duration_ms are thrown out.
+
max_speech_duration_s – Maximum duration of speech chunks in seconds. Chunks longer than
+max_speech_duration_s will be split at the timestamp of the last silence that
+lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+be split aggressively just before max_speech_duration_s.
+
min_silence_duration_ms – In the end of each speech chunk wait for min_silence_duration_ms before separating
+it.
+
window_size_samples –
Audio chunks of window_size_samples size are fed to the silero VAD model.
+
WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+these may affect model performance!
+
+
speech_pad_ms – Final speech chunks are padded by speech_pad_ms each side.
+
return_seconds – Whether return timestamps in seconds. False means to return timestamps in samples
+(default - False).
+
per_channel – Whether to return timestamps per channel (default - False). This will run VAD on
+each channel separately and return a list of timestamps per channel.
+
use_multiprocessing – The number of workers to use for multiprocessing. If 0, no multiprocessing will
+be used. Default is 0.
Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
+The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
+end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+of tuples: (start, end, speaker_label).
data_path – The path to the audio files to diarize. Can be a path to a single file, a path to a
+directory or a list of paths to files.
+
use_onnx – Whether to use ONNX for inference. Default is True.
+
force_onnx_cpu – Whether to force ONNX to use CPU for inference. Default is True.
+
threshold – Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+probabilities ABOVE this value are considered as SPEECH. It is better to tune
+this parameter for each dataset separately, but “lazy” 0.5 is pretty good for
+most datasets.
+
sampling_rate – Currently, silero VAD models support 8000 and 16000 sample rates.
+
min_speech_duration_ms – Final speech chunks shorter min_speech_duration_ms are thrown out.
+
max_speech_duration_s – Maximum duration of speech chunks in seconds. Chunks longer than
+max_speech_duration_s will be split at the timestamp of the last silence that
+lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+be split aggressively just before max_speech_duration_s.
+
min_silence_duration_ms – In the end of each speech chunk wait for min_silence_duration_ms before separating
+it.
+
window_size_samples –
Audio chunks of window_size_samples size are fed to the silero VAD model.
+
WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+these may affect model performance!
+
+
speech_pad_ms – Final speech chunks are padded by speech_pad_ms each side.
+
speaker_labels – The speaker labels to use for the diarization. If not given, the speakers will be
+named “speaker_0”, “speaker_1”, etc.
+
use_multiprocessing – The number of workers to use for multiprocessing. If 0, no multiprocessing will
+be used. Default is 0.
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/silero_vad/1.2.0/static/function.html b/functions/development/silero_vad/1.2.0/static/function.html
new file mode 100644
index 00000000..0f90fdfc
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/static/function.html
@@ -0,0 +1,313 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+
+kind: job
+metadata:
+ name: silero-vad
+ tag: ''
+ hash: 61b7a70c167b7819481fdabf9350fc6fa344d2f5
+ project: ''
+ labels:
+ author: guyl
+ categories:
+ - deep-learning
+ - PyTorch
+ - Audio
+spec:
+ command: ''
+ args: []
+ image: ''
+ build:
+ functionSourceCode: # Copyright 2024 Iguazio
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from multiprocessing import Process, Queue
from pathlib import Path
from types import FunctionType
from typing import Dict, List, Tuple, Type, Union

import torch
import torchaudio
from tqdm import tqdm


class BaseTask:
    """
    A base class for a task to complete after VAD.
    """

    def __init__(self, audio_file: Path):
        """
        Initialize the base task.

        :param audio_file: The audio file assigned to the task.
        """
        # Store the audio file:
        self._audio_file = audio_file

        # Prepare the result:
        self._result = None

    @property
    def audio_file(self) -> Path:
        """
        Get the audio file of the task.

        :returns: The audio file of the task.
        """
        return self._audio_file

    def do_task(
        self, speech_timestamps: Union[List[Dict[str, int]], List[List[Dict[str, int]]]]
    ):
        """
        Do the task on the given speech timestamps. The base task will simply save the speech timestamps as the result.

        :param speech_timestamps: The speech timestamps to do the task on as outputted from the VAD.
        """
        self._result = speech_timestamps

    def get_result(self) -> Tuple[str, list]:
        """
        Get the result of the task. A tuple of the audio file name and the result.

        :returns: The result of the task.
        """
        return self._audio_file.name, self._result

    def to_tuple(self) -> Tuple[str, dict]:
        """
        Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).

        :returns: The converted task.
        """
        return self.__class__.__name__, {"audio_file": self._audio_file}


class SpeechDiarizationTask(BaseTask):
    """
    A speech diarization task. The task will diarize the VAD speech timestamps into speakers.
    """

    def __init__(self, audio_file: Path, speaker_labels: List[str]):
        """
        Initialize the speech diarization task.

        :param audio_file:     The audio file assigned to the task.
        :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be named
                               "speaker_0", "speaker_1", etc.
        """
        super().__init__(audio_file=audio_file)
        self._speaker_labels = speaker_labels

    def do_task(self, speech_timestamps: List[List[Dict[str, int]]]):
        """
        Do the task on the given speech timestamps. The task will diarize the VAD speech timestamps into speakers.

        :param speech_timestamps: The speech timestamps per channel to do the task on as outputted from the VAD.
        """
        # Get the speaker labels (set default if not given):
        speaker_labels = self._speaker_labels or [
            f"speaker_{i}" for i in range(len(speech_timestamps))
        ]

        # Diarize - organize the speech timestamps into a single list of speakers and sort it by start time:
        speech_diarization = [
            (speech_timestamp["start"], speech_timestamp["end"], speaker_label)
            for speaker_label, channel_speech_timestamps in zip(
                speaker_labels, speech_timestamps
            )
            for speech_timestamp in channel_speech_timestamps
        ]
        speech_diarization.sort()
        self._result = speech_diarization

    def to_tuple(self) -> Tuple[str, dict]:
        """
        Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).

        :returns: The converted task.
        """
        task_class, task_kwargs = super().to_tuple()
        return task_class, {**task_kwargs, "speaker_labels": self._speaker_labels}


class TaskCreator:
    """
    A task creator to create different tasks to run after the VAD.
    """

    #: A map from task class name to task class to use in `from_tuple`:
    _MAP = {
        BaseTask.__name__: BaseTask,
        SpeechDiarizationTask.__name__: SpeechDiarizationTask,
    }

    def __init__(self, task_type: Type[BaseTask], task_kwargs: dict = None):
        """
        Initialize the task creator.
        :param task_type: The task type - a `BaseTask` subclass.
        :param task_kwargs: Additional keyword arguments to pass to the to be created tasks.
        """
        self._task_type = task_type
        self._task_kwargs = task_kwargs or {}

    def create_task(self, audio_file: Path) -> BaseTask:
        """
        Create a task with the given audio file.

        :param audio_file: The audio file to assign to the task.

        :returns: The created task.
        """
        return self._task_type(audio_file=audio_file, **self._task_kwargs)

    @classmethod
    def from_tuple(cls, task_tuple: Tuple[str, dict]) -> BaseTask:
        """
        Create a task from a tuple of the audio file name and the task kwargs.

        :param task_tuple: The task tuple to create the task from.

        :returns: The created task.
        """
        task_class, task_kwargs = task_tuple
        return cls._MAP[task_class](**task_kwargs)


class VoiceActivityDetector:
    """
    A voice activity detection wrapper for the silero VAD model - https://github.com/snakers4/silero-vad.
    """

    def __init__(
        self,
        # Model loading kwargs:
        use_onnx: bool = True,
        force_onnx_cpu: bool = True,
        # Detection kwargs:
        threshold: float = 0.5,
        sampling_rate: int = 16_000,
        min_speech_duration_ms: int = 250,
        max_speech_duration_s: float = float("inf"),
        min_silence_duration_ms: int = 100,
        window_size_samples: int = 512,
        speech_pad_ms: int = 30,
        return_seconds: bool = False,
        per_channel: bool = False,
    ):
        """
        Initialize the voice activity detector.

        :param use_onnx:                Whether to use ONNX for inference. Default is True.
        :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
        :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                        probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                        this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                        most datasets.
        :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
        :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
        :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                        `max_speech_duration_s` will be split at the timestamp of the last silence that
                                        lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise,
                                        they will be split aggressively just before max_speech_duration_s.
        :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before
                                        separating it.
        :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.
                                        WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                        sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                        these may affect model performance!
        :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
        :param return_seconds:          Whether return timestamps in seconds. False means to return timestamps in
                                        samples (default - False).
        :param per_channel:             Whether to return timestamps per channel (default - False). This will run VAD
                                        on each channel separately and return a list of timestamps per channel.
        """
        # Store configurations:
        self._use_onnx = use_onnx
        self._force_onnx_cpu = force_onnx_cpu
        self._threshold = threshold
        self._sampling_rate = sampling_rate
        self._min_speech_duration_ms = min_speech_duration_ms
        self._max_speech_duration_s = max_speech_duration_s
        self._min_silence_duration_ms = min_silence_duration_ms
        self._window_size_samples = window_size_samples
        self._speech_pad_ms = speech_pad_ms
        self._return_seconds = return_seconds
        self._per_channel = per_channel

        # Prepare the model variables
        self._model: torch.Module = None
        self._get_speech_timestamps: FunctionType = None

    def load(self, force_reload: bool = True):
        """
        Load the VAD model.

        :param force_reload: Whether to force reload the model even if it was already loaded. Default is True.
        """
        model, utils = torch.hub.load(
            repo_or_dir="snakers4/silero-vad",
            model="silero_vad",
            force_reload=force_reload,
            onnx=self._use_onnx,
            force_onnx_cpu=self._force_onnx_cpu,
        )
        self._model = model
        (
            self._get_speech_timestamps,
            _,  # save_audio,
            _,  # read_audio,
            _,  # VADIterator,
            _,  # collect_chunks
        ) = utils

    def detect_voice(
        self,
        audio_file: Path,
    ) -> Union[List[Dict[str, int]], List[List[Dict[str, int]]]]:
        """
        Infer the audio through the VAD model and return the speech timestamps.

        :param audio_file: The audio file to infer.

        :returns: The speech timestamps in the audio. A list of timestamps where each timestamp is a dictionary with the
                 following keys:

                 * "start": The start sample index of the speech in the audio.
                 * "end":   The end sample index of the speech in the audio.

                 If `per_channel` is True, a list of timestamps per channel will be returned.
        """
        # Cast to a numpy array:
        audio = self._read_audio(audio_file)

        # Detect speech:
        if not self._per_channel:
            return self._get_speech_timestamps(
                audio,
                self._model,
                threshold=self._threshold,
                min_speech_duration_ms=self._min_speech_duration_ms,
                max_speech_duration_s=self._max_speech_duration_s,
                min_silence_duration_ms=self._min_silence_duration_ms,
                speech_pad_ms=self._speech_pad_ms,
                sampling_rate=self._sampling_rate,
                window_size_samples=self._window_size_samples,
                return_seconds=self._return_seconds,
            )

        # Per channel:
        speech_timestamps = []
        for channel in audio:
            speech_timestamps.append(
                self._get_speech_timestamps(
                    channel,
                    self._model,
                    threshold=self._threshold,
                    min_speech_duration_ms=self._min_speech_duration_ms,
                    max_speech_duration_s=self._max_speech_duration_s,
                    min_silence_duration_ms=self._min_silence_duration_ms,
                    speech_pad_ms=self._speech_pad_ms,
                    sampling_rate=self._sampling_rate,
                    window_size_samples=self._window_size_samples,
                    return_seconds=self._return_seconds,
                )
            )

        return speech_timestamps

    def _read_audio(
        self,
        path: Path,
    ) -> torch.Tensor:
        """
        Read the audio from the given path and return it as a tensor.

        :param path: The path to the audio file.

        :returns: The audio as a tensor.
        """
        # Read the audio:
        audio, sampling_rate = torchaudio.load(str(path))

        # Check if the audio is stereo and if so, convert it to mono (only if not per channel):
        if audio.size(0) > 1 and not self._per_channel:
            audio = audio.mean(dim=0, keepdim=True)

        # Resample the audio if needed:
        if sampling_rate != self._sampling_rate:
            transform = torchaudio.transforms.Resample(
                orig_freq=sampling_rate, new_freq=self._sampling_rate
            )
            audio = transform(audio)

        # Return the audio (squeeze if not per channel):
        return audio if self._per_channel else audio.squeeze(0)


#: The value to send into multiprocessing queues to stop the process:
_MULTIPROCESSING_STOP_MARK = "STOP"


def _multiprocessing_complete_tasks(
    vad_init_kwargs: dict, tasks_queue: Queue, results_queue: Queue
):
    """
    Complete the tasks in the given queue and put the results in the given results queue. The function will stop when
    the given tasks queue will receive the stop mark. It is aimed to be used with multiprocessing as a process.

    :param vad_init_kwargs: The VAD initialization kwargs.
    :param tasks_queue:     A queue to get the tasks from.
    :param results_queue:   A queue to put the results in.
    """
    # Initialize and load the VAD:
    vad = VoiceActivityDetector(**vad_init_kwargs)
    vad.load(force_reload=False)

    # Start listening to the tasks queue:
    while True:
        # Get the task:
        task: Tuple[str, dict] = tasks_queue.get()
        if task == _MULTIPROCESSING_STOP_MARK:
            break
        try:
            # Create the task:
            task = TaskCreator.from_tuple(task_tuple=task)
            # Run the file through the VAD:
            speech_timestamps = vad.detect_voice(audio_file=task.audio_file)
            # Complete the task:
            task.do_task(speech_timestamps=speech_timestamps)
            # Build the result:
            result = (False, task.get_result())
        except Exception as exception:
            # Build the error:
            result = (True, (task.audio_file.name, str(exception)))
        # Collect the result / error:
        results_queue.put(result)

    # Mark the end of the tasks:
    results_queue.put(_MULTIPROCESSING_STOP_MARK)


# Get the global logger:
try:
    import mlrun

    _LOGGER = mlrun.get_or_create_ctx("silero_vad").logger
except ModuleNotFoundError:
    _LOGGER = logging.getLogger()


def detect_voice(
    # Input kwargs:
    data_path: Union[str, Path, List[Union[str, Path]]],
    # Model loading kwargs:
    use_onnx: bool = True,
    force_onnx_cpu: bool = True,
    # Detection kwargs:
    threshold: float = 0.5,
    sampling_rate: int = 16_000,
    min_speech_duration_ms: int = 250,
    max_speech_duration_s: float = float("inf"),
    min_silence_duration_ms: int = 100,
    window_size_samples: int = 512,
    speech_pad_ms: int = 30,
    return_seconds: bool = False,
    per_channel: bool = False,
    # Other kwargs:
    use_multiprocessing: int = 0,
    verbose: bool = False,
):
    """
    Perform voice activity detection on given audio files using the silero VAD model -
    https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
    VAD timestamps dictionaries as value.

    For example::

        {
            "file_1.wav": [
                {"start": 0, "end": 16000},
                {"start": 16000, "end": 32000},
                {"start": 32000, "end": 48000},
                ...
            ],
            "file_2.wav": [
                {"start": 0, "end": 16000},
                {"start": 16000, "end": 32000},
                {"start": 32000, "end": 48000},
                ...
            ],
            ...
        }


    :param data_path:               The path to the audio files to diarize. Can be a path to a single file, a path to a
                                    directory or a list of paths to files.
    :param use_onnx:                Whether to use ONNX for inference. Default is True.
    :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
    :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                    probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                    this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                    most datasets.
    :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
    :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
    :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                    `max_speech_duration_s` will be split at the timestamp of the last silence that
                                    lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
                                    be split aggressively just before max_speech_duration_s.
    :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
                                    it.
    :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.

                                    WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                    sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                    these may affect model performance!
    :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
    :param return_seconds:          Whether return timestamps in seconds. False means to return timestamps in samples
                                    (default - False).
    :param per_channel:             Whether to return timestamps per channel (default - False). This will run VAD on
                                    each channel separately and return a list of timestamps per channel.
    :param use_multiprocessing:     The number of workers to use for multiprocessing. If 0, no multiprocessing will
                                    be used. Default is 0.
    :param verbose:                 Verbosity.
    """
    global _LOGGER

    # Get the input audio files to transcribe:
    if verbose:
        _LOGGER.info("Collecting audio files.")
    audio_files = _get_audio_files(data_path=data_path)
    if verbose:
        _LOGGER.info(f"Collected {len(audio_files)} audio files.")

    # Initialize the transcription pipeline:
    vad_init_kwargs = {
        "use_onnx": use_onnx,
        "force_onnx_cpu": force_onnx_cpu,
        "threshold": threshold,
        "sampling_rate": sampling_rate,
        "min_speech_duration_ms": min_speech_duration_ms,
        "max_speech_duration_s": max_speech_duration_s,
        "min_silence_duration_ms": min_silence_duration_ms,
        "window_size_samples": window_size_samples,
        "speech_pad_ms": speech_pad_ms,
        "return_seconds": return_seconds,
        "per_channel": per_channel,
    }

    # Create the task creator:
    task_creator = TaskCreator(task_type=BaseTask)

    # Run the transcription:
    if use_multiprocessing:
        results = _parallel_run(
            n_workers=use_multiprocessing,
            audio_files=audio_files,
            description="Detecting voice",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )
    else:
        results = _run(
            audio_files=audio_files,
            description="Detecting voice",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )

    # Process the results:
    return _process_results(results=results, verbose=verbose)


def diarize(
    # Input / Output kwargs:
    data_path: Union[str, Path, List[Union[str, Path]]],
    # Model loading kwargs:
    use_onnx: bool = True,
    force_onnx_cpu: bool = True,
    # Detection kwargs:
    threshold: float = 0.5,
    sampling_rate: int = 16_000,
    min_speech_duration_ms: int = 250,
    max_speech_duration_s: float = float("inf"),
    min_silence_duration_ms: int = 100,
    window_size_samples: int = 512,
    speech_pad_ms: int = 30,
    # Diarization kwargs:
    speaker_labels: List[str] = None,
    # Other kwargs:
    use_multiprocessing: int = 0,
    verbose: bool = False,
):
    """
    Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
    The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
    end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
    of tuples: (start, end, speaker_label).

    For example::

        {
            "file_1.wav": [
                (0.0, 1.0, "speaker_0"),
                (1.0, 2.0, "speaker_1"),
                (2.0, 3.0, "speaker_0"),
                ...
            ],
            "file_2.wav": [
                (0.0, 1.0, "speaker_0"),
                (1.0, 2.0, "speaker_1"),
                (2.0, 3.0, "speaker_0"),
                ...
            ],
            ...
        }


    :param data_path:               The path to the audio files to diarize. Can be a path to a single file, a path to a
                                    directory or a list of paths to files.
    :param use_onnx:                Whether to use ONNX for inference. Default is True.
    :param force_onnx_cpu:          Whether to force ONNX to use CPU for inference. Default is True.
    :param threshold:               Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
                                    probabilities ABOVE this value are considered as SPEECH. It is better to tune
                                    this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
                                    most datasets.
    :param sampling_rate:           Currently, silero VAD models support 8000 and 16000 sample rates.
    :param min_speech_duration_ms:  Final speech chunks shorter min_speech_duration_ms are thrown out.
    :param max_speech_duration_s:   Maximum duration of speech chunks in seconds. Chunks longer than
                                    `max_speech_duration_s` will be split at the timestamp of the last silence that
                                    lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
                                    be split aggressively just before max_speech_duration_s.
    :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
                                    it.
    :param window_size_samples:     Audio chunks of window_size_samples size are fed to the silero VAD model.

                                    WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
                                    sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
                                    these may affect model performance!
    :param speech_pad_ms:           Final speech chunks are padded by speech_pad_ms each side.
    :param speaker_labels:          The speaker labels to use for the diarization. If not given, the speakers will be
                                    named "speaker_0", "speaker_1", etc.
    :param use_multiprocessing:     The number of workers to use for multiprocessing. If 0, no multiprocessing will
                                    be used. Default is 0.
    :param verbose:                 Verbosity.
    """
    global _LOGGER

    # Get the input audio files to transcribe:
    if verbose:
        _LOGGER.info("Collecting audio files.")
    audio_files = _get_audio_files(data_path=data_path)
    if verbose:
        _LOGGER.info(f"Collected {len(audio_files)} audio files.")

    # Initialize the transcription pipeline:
    vad_init_kwargs = {
        "use_onnx": use_onnx,
        "force_onnx_cpu": force_onnx_cpu,
        "threshold": threshold,
        "sampling_rate": sampling_rate,
        "min_speech_duration_ms": min_speech_duration_ms,
        "max_speech_duration_s": max_speech_duration_s,
        "min_silence_duration_ms": min_silence_duration_ms,
        "window_size_samples": window_size_samples,
        "speech_pad_ms": speech_pad_ms,
        "return_seconds": True,
        "per_channel": True,
    }

    # Create the task creator:
    task_creator = TaskCreator(
        task_type=SpeechDiarizationTask, task_kwargs={"speaker_labels": speaker_labels}
    )

    # Run the transcription:
    if use_multiprocessing:
        results = _parallel_run(
            n_workers=use_multiprocessing,
            audio_files=audio_files,
            description="Diarizing",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )
    else:
        results = _run(
            audio_files=audio_files,
            description="Diarizing",
            vad_init_kwargs=vad_init_kwargs,
            task_creator=task_creator,
            verbose=verbose,
        )

    # Process the results:
    return _process_results(results=results, verbose=verbose)


def _get_audio_files(
    data_path: Union[Path, str, list],
) -> List[Path]:
    """
    Get the audio files from the data path. If a path to a directory is given, all files in the directory will be
    collected.

    :param data_path: The data path to collect the audio files from.

    :returns: The audio files list.
    """
    # Check if given a list of paths:
    if isinstance(data_path, list):
        audio_files = []
        for path in data_path:
            audio_files.extend(_get_audio_files(data_path=path))
        return audio_files

    # Check if given a single string path to cast it to a `pathlib.Path`:
    if isinstance(data_path, str):
        data_path = Path(data_path).absolute()

    # Check if the path is of a directory or a file:
    if data_path.is_dir():
        # Get all files inside the directory:
        audio_files = list(data_path.glob("*.*"))
    elif data_path.is_file():
        audio_files = [data_path]
    else:
        raise ValueError(
            f"Unrecognized data path. The parameter `data_path` must be a valid path to either a directory path or a "
            f"file. Given: {str(data_path)} "
        )

    return audio_files


def _run(
    audio_files: List[Path],
    description: str,
    vad_init_kwargs: dict,
    task_creator: TaskCreator,
    verbose: bool,
) -> List[Tuple[bool, Tuple[str, list]]]:
    """
    Load a VAD and use it to complete the tasks that will be created on the provided files using the given task creator.

    :param audio_files:     The audio files to use.
    :param description:     The description to use for the progress bar.
    :param vad_init_kwargs: The VAD initialization keyword arguments.
    :param task_creator:    The task creator to use to create the tasks.
    :param verbose:         Verbosity.

    :returns: The collected results.
    """
    # Load the VAD:
    vad = VoiceActivityDetector(**vad_init_kwargs)
    if verbose:
        _LOGGER.info(f"Loading the VAD model.")
    vad.load()
    if verbose:
        _LOGGER.info("VAD model loaded.")

    # Run the VAD on the audio files and collect the results:
    results = []
    for audio_file in tqdm(
        audio_files,
        desc=description,
        unit="file",
        total=len(audio_files),
        disable=not verbose,
    ):
        try:
            # Create the task:
            task = task_creator.create_task(audio_file=audio_file)
            # Run the file through the VAD:
            speech_timestamps = vad.detect_voice(audio_file=audio_file)
            # Complete the task:
            task.do_task(speech_timestamps=speech_timestamps)
            # Collect the result:
            results.append((False, task.get_result()))
        except Exception as exception:
            # Collect the error:
            results.append((True, (audio_file.name, str(exception))))

    return results


def _parallel_run(
    n_workers: int,
    audio_files: List[Path],
    description: str,
    vad_init_kwargs: dict,
    task_creator: TaskCreator,
    verbose: bool,
) -> List[Tuple[bool, Tuple[str, list]]]:
    """
    Run multiple VAD workers with multiprocessing to complete the tasks that will be created on the provided files using
    the given task creator.

    :param n_workers:       The number of workers to use.
    :param audio_files:     The audio files to use.
    :param description:     The description to use for the progress bar.
    :param vad_init_kwargs: The VAD initialization keyword arguments.
    :param task_creator:    The task creator to use to create the tasks.
    :param verbose:         Verbosity.

    :returns: The collected results.
    """
    # Load the VAD (download once, and it will be loaded then per process later on):
    if verbose:
        _LOGGER.info(f"Loading the VAD model.")
    vad = VoiceActivityDetector(**vad_init_kwargs)
    vad.load()
    if verbose:
        _LOGGER.info("VAD model loaded.")

    # Check the number of workers:
    if n_workers > len(audio_files):
        _LOGGER.warning(
            f"The number of workers ({n_workers}) is larger than the number of audio files ({len(audio_files)}). "
            f"Setting the number of workers to {len(audio_files)}."
        )
        n_workers = len(audio_files)

    # Initialize the multiprocessing queues:
    tasks_queue = Queue()
    results_queue = Queue()

    # Initialize the multiprocessing processes:
    task_completion_processes = [
        Process(
            target=_multiprocessing_complete_tasks,
            kwargs={
                "vad_init_kwargs": vad_init_kwargs,
                "tasks_queue": tasks_queue,
                "results_queue": results_queue,
            },
        )
        for _ in range(n_workers)
    ]

    # Start the multiprocessing processes:
    for p in task_completion_processes:
        p.start()

    # Put the tasks in the queue:
    for audio_file in audio_files:
        tasks_queue.put(task_creator.create_task(audio_file=audio_file).to_tuple())

    # Put the stop marks in the queue:
    for _ in range(n_workers):
        tasks_queue.put(_MULTIPROCESSING_STOP_MARK)

    # Collect the results:
    results = []
    stop_marks_counter = 0
    with tqdm(
        desc=description,
        unit="file",
        total=len(audio_files),
        disable=not verbose,
    ) as progressbar:
        while True:
            # Get a result from the queue:
            result: Tuple[bool, Tuple[str, list]] = results_queue.get()
            if result == _MULTIPROCESSING_STOP_MARK:
                stop_marks_counter += 1
                if stop_marks_counter == n_workers:
                    break
            else:
                # Collect the result:
                results.append(result)
                progressbar.update(1)

    # Wait for the processes to finish:
    for p in task_completion_processes:
        p.join()

    return results


def _process_results(
    results: List[Tuple[bool, Tuple[str, list]]], verbose: bool
) -> Tuple[dict, dict]:
    """
    Process the results of the tasks.

    :param results: The results to process.
    :param verbose: Verbosity.

    :returns: The processed results as a tuple of successes and errors.
    """
    if verbose:
        _LOGGER.info("Summarizing the results.")
    successes = {}
    errors = {}
    for is_error, result in results:
        if is_error:
            errors[result[0]] = result[1]
        else:
            successes[result[0]] = result[1]
    if verbose:
        _LOGGER.info(f"Done ({len(successes)}/{len(successes) + len(errors)})\n")

    return successes, errors

+ base_image: mlrun/mlrun
+ commands: []
+ code_origin: ''
+ origin_filename: ''
+ requirements:
+ - torch
+ - torchaudio
+ - tqdm
+ - onnxruntime
+ entry_points:
+ audio_file:
+ name: audio_file
+ doc: Get the audio file of the task.
+ parameters:
+ - name: self
+ outputs:
+ - doc: The audio file of the task.
+ type: Path
+ lineno: 43
+ has_varargs: false
+ has_kwargs: false
+ do_task:
+ name: do_task
+ doc: Do the task on the given speech timestamps. The task will diarize the VAD
+ speech timestamps into speakers.
+ parameters:
+ - name: self
+ - name: speech_timestamps
+ type: List[List[Dict[str, int]]]
+ doc: The speech timestamps per channel to do the task on as outputted from
+ the VAD.
+ outputs: []
+ lineno: 94
+ has_varargs: false
+ has_kwargs: false
+ get_result:
+ name: get_result
+ doc: Get the result of the task. A tuple of the audio file name and the result.
+ parameters:
+ - name: self
+ outputs:
+ - doc: The result of the task.
+ type: Tuple[str, list]
+ lineno: 61
+ has_varargs: false
+ has_kwargs: false
+ to_tuple:
+ name: to_tuple
+ doc: Convert the task to a tuple to reconstruct it later (used for multiprocessing
+ to pass in queue).
+ parameters:
+ - name: self
+ outputs:
+ - doc: The converted task.
+ type: Tuple[str, dict]
+ lineno: 116
+ has_varargs: false
+ has_kwargs: false
+ create_task:
+ name: create_task
+ doc: Create a task with the given audio file.
+ parameters:
+ - name: self
+ - name: audio_file
+ type: Path
+ doc: The audio file to assign to the task.
+ outputs:
+ - doc: The created task.
+ type: BaseTask
+ lineno: 146
+ has_varargs: false
+ has_kwargs: false
+ from_tuple:
+ name: from_tuple
+ doc: Create a task from a tuple of the audio file name and the task kwargs.
+ parameters:
+ - name: cls
+ - name: task_tuple
+ type: Tuple[str, dict]
+ doc: The task tuple to create the task from.
+ outputs:
+ - doc: The created task.
+ type: BaseTask
+ lineno: 157
+ has_varargs: false
+ has_kwargs: false
+ load:
+ name: load
+ doc: Load the VAD model.
+ parameters:
+ - name: self
+ - name: force_reload
+ type: bool
+ doc: Whether to force reload the model even if it was already loaded. Default
+ is True.
+ default: true
+ outputs: []
+ lineno: 234
+ has_varargs: false
+ has_kwargs: false
+ detect_voice:
+ name: detect_voice
+ doc: "Perform voice activity detection on given audio files using the silero\
+ \ VAD model -\nhttps://github.com/snakers4/silero-vad. The end result is a\
+ \ dictionary with the file names as keys and their\nVAD timestamps dictionaries\
+ \ as value.\n\nFor example::\n\n {\n \"file_1.wav\": [\n \
+ \ {\"start\": 0, \"end\": 16000},\n {\"start\": 16000, \"end\"\
+ : 32000},\n {\"start\": 32000, \"end\": 48000},\n ...\n\
+ \ ],\n \"file_2.wav\": [\n {\"start\": 0, \"end\"\
+ : 16000},\n {\"start\": 16000, \"end\": 32000},\n {\"\
+ start\": 32000, \"end\": 48000},\n ...\n ],\n ...\n\
+ \ }"
+ parameters:
+ - name: data_path
+ type: Union[str, Path, List[Union[str, Path]]]
+ doc: The path to the audio files to diarize. Can be a path to a single file,
+ a path to a directory or a list of paths to files.
+ - name: use_onnx
+ type: bool
+ doc: Whether to use ONNX for inference. Default is True.
+ default: true
+ - name: force_onnx_cpu
+ type: bool
+ doc: Whether to force ONNX to use CPU for inference. Default is True.
+ default: true
+ - name: threshold
+ type: float
+ doc: Speech threshold. Silero VAD outputs speech probabilities for each audio
+ chunk, probabilities ABOVE this value are considered as SPEECH. It is better
+ to tune this parameter for each dataset separately, but "lazy" 0.5 is pretty
+ good for most datasets.
+ default: 0.5
+ - name: sampling_rate
+ type: int
+ doc: Currently, silero VAD models support 8000 and 16000 sample rates.
+ default: 16000
+ - name: min_speech_duration_ms
+ type: int
+ doc: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ default: 250
+ - name: max_speech_duration_s
+ type: float
+ doc: Maximum duration of speech chunks in seconds. Chunks longer than `max_speech_duration_s`
+ will be split at the timestamp of the last silence that lasts more than
+ 100ms (if any), to prevent aggressive cutting. Otherwise, they will be split
+ aggressively just before max_speech_duration_s.
+ default: float('inf')
+ - name: min_silence_duration_ms
+ type: int
+ doc: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ default: 100
+ - name: window_size_samples
+ type: int
+ doc: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ default: 512
+ - name: speech_pad_ms
+ type: int
+ doc: Final speech chunks are padded by speech_pad_ms each side.
+ default: 30
+ - name: return_seconds
+ type: bool
+ doc: Whether return timestamps in seconds. False means to return timestamps
+ in samples (default - False).
+ default: false
+ - name: per_channel
+ type: bool
+ doc: Whether to return timestamps per channel (default - False). This will
+ run VAD on each channel separately and return a list of timestamps per channel.
+ default: false
+ - name: use_multiprocessing
+ type: int
+ doc: The number of workers to use for multiprocessing. If 0, no multiprocessing
+ will be used. Default is 0.
+ default: 0
+ - name: verbose
+ type: bool
+ doc: Verbosity.
+ default: false
+ outputs: []
+ lineno: 393
+ has_varargs: false
+ has_kwargs: false
+ diarize:
+ name: diarize
+ doc: "Perform speech diarization on given audio files using the silero VAD model\
+ \ - https://github.com/snakers4/silero-vad.\nThe speech diarization is performed\
+ \ per channel so that each channel in the audio belong to a different speaker.\
+ \ The\nend result is a dictionary with the file names as keys and their diarization\
+ \ as value. A diarization is a list\nof tuples: (start, end, speaker_label).\n\
+ \nFor example::\n\n {\n \"file_1.wav\": [\n (0.0, 1.0,\
+ \ \"speaker_0\"),\n (1.0, 2.0, \"speaker_1\"),\n (2.0,\
+ \ 3.0, \"speaker_0\"),\n ...\n ],\n \"file_2.wav\"\
+ : [\n (0.0, 1.0, \"speaker_0\"),\n (1.0, 2.0, \"speaker_1\"\
+ ),\n (2.0, 3.0, \"speaker_0\"),\n ...\n ],\n\
+ \ ...\n }"
+ parameters:
+ - name: data_path
+ type: Union[str, Path, List[Union[str, Path]]]
+ doc: The path to the audio files to diarize. Can be a path to a single file,
+ a path to a directory or a list of paths to files.
+ - name: use_onnx
+ type: bool
+ doc: Whether to use ONNX for inference. Default is True.
+ default: true
+ - name: force_onnx_cpu
+ type: bool
+ doc: Whether to force ONNX to use CPU for inference. Default is True.
+ default: true
+ - name: threshold
+ type: float
+ doc: Speech threshold. Silero VAD outputs speech probabilities for each audio
+ chunk, probabilities ABOVE this value are considered as SPEECH. It is better
+ to tune this parameter for each dataset separately, but "lazy" 0.5 is pretty
+ good for most datasets.
+ default: 0.5
+ - name: sampling_rate
+ type: int
+ doc: Currently, silero VAD models support 8000 and 16000 sample rates.
+ default: 16000
+ - name: min_speech_duration_ms
+ type: int
+ doc: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ default: 250
+ - name: max_speech_duration_s
+ type: float
+ doc: Maximum duration of speech chunks in seconds. Chunks longer than `max_speech_duration_s`
+ will be split at the timestamp of the last silence that lasts more than
+ 100ms (if any), to prevent aggressive cutting. Otherwise, they will be split
+ aggressively just before max_speech_duration_s.
+ default: float('inf')
+ - name: min_silence_duration_ms
+ type: int
+ doc: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ default: 100
+ - name: window_size_samples
+ type: int
+ doc: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ default: 512
+ - name: speech_pad_ms
+ type: int
+ doc: Final speech chunks are padded by speech_pad_ms each side.
+ default: 30
+ - name: speaker_labels
+ type: List[str]
+ doc: The speaker labels to use for the diarization. If not given, the speakers
+ will be named "speaker_0", "speaker_1", etc.
+ default: null
+ - name: use_multiprocessing
+ type: int
+ doc: The number of workers to use for multiprocessing. If 0, no multiprocessing
+ will be used. Default is 0.
+ default: 0
+ - name: verbose
+ type: bool
+ doc: Verbosity.
+ default: false
+ outputs: []
+ lineno: 517
+ has_varargs: false
+ has_kwargs: false
+ description: Silero VAD (Voice Activity Detection) functions.
+ default_handler: detect_voice
+ disable_auto_mount: false
+ clone_target_dir: ''
+ env: []
+ priority_class_name: ''
+ preemption_mode: prevent
+ affinity: null
+ tolerations: null
+ security_context: {}
+verbose: false
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/silero_vad/1.2.0/static/item.html b/functions/development/silero_vad/1.2.0/static/item.html
new file mode 100644
index 00000000..5c26352e
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/static/item.html
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+# Copyright 2024 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+importlogging
+frommultiprocessingimportProcess,Queue
+frompathlibimportPath
+fromtypesimportFunctionType
+fromtypingimportDict,List,Tuple,Type,Union
+
+importtorch
+importtorchaudio
+fromtqdmimporttqdm
+
+
+
[docs]classBaseTask:
+"""
+ A base class for a task to complete after VAD.
+ """
+
+ def__init__(self,audio_file:Path):
+"""
+ Initialize the base task.
+
+ :param audio_file: The audio file assigned to the task.
+ """
+ # Store the audio file:
+ self._audio_file=audio_file
+
+ # Prepare the result:
+ self._result=None
+
+ @property
+ defaudio_file(self)->Path:
+"""
+ Get the audio file of the task.
+
+ :returns: The audio file of the task.
+ """
+ returnself._audio_file
+
+
[docs]defdo_task(
+ self,speech_timestamps:Union[List[Dict[str,int]],List[List[Dict[str,int]]]]
+ ):
+"""
+ Do the task on the given speech timestamps. The base task will simply save the speech timestamps as the result.
+
+ :param speech_timestamps: The speech timestamps to do the task on as outputted from the VAD.
+ """
+ self._result=speech_timestamps
+
+
[docs]defget_result(self)->Tuple[str,list]:
+"""
+ Get the result of the task. A tuple of the audio file name and the result.
+
+ :returns: The result of the task.
+ """
+ returnself._audio_file.name,self._result
+
+
[docs]defto_tuple(self)->Tuple[str,dict]:
+"""
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ returnself.__class__.__name__,{"audio_file":self._audio_file}
+
+
+
[docs]classSpeechDiarizationTask(BaseTask):
+"""
+ A speech diarization task. The task will diarize the VAD speech timestamps into speakers.
+ """
+
+ def__init__(self,audio_file:Path,speaker_labels:List[str]):
+"""
+ Initialize the speech diarization task.
+
+ :param audio_file: The audio file assigned to the task.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be named
+ "speaker_0", "speaker_1", etc.
+ """
+ super().__init__(audio_file=audio_file)
+ self._speaker_labels=speaker_labels
+
+
[docs]defdo_task(self,speech_timestamps:List[List[Dict[str,int]]]):
+"""
+ Do the task on the given speech timestamps. The task will diarize the VAD speech timestamps into speakers.
+
+ :param speech_timestamps: The speech timestamps per channel to do the task on as outputted from the VAD.
+ """
+ # Get the speaker labels (set default if not given):
+ speaker_labels=self._speaker_labelsor[
+ f"speaker_{i}"foriinrange(len(speech_timestamps))
+ ]
+
+ # Diarize - organize the speech timestamps into a single list of speakers and sort it by start time:
+ speech_diarization=[
+ (speech_timestamp["start"],speech_timestamp["end"],speaker_label)
+ forspeaker_label,channel_speech_timestampsinzip(
+ speaker_labels,speech_timestamps
+ )
+ forspeech_timestampinchannel_speech_timestamps
+ ]
+ speech_diarization.sort()
+ self._result=speech_diarization
+
+
[docs]defto_tuple(self)->Tuple[str,dict]:
+"""
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ task_class,task_kwargs=super().to_tuple()
+ returntask_class,{**task_kwargs,"speaker_labels":self._speaker_labels}
+
+
+
[docs]classTaskCreator:
+"""
+ A task creator to create different tasks to run after the VAD.
+ """
+
+ #: A map from task class name to task class to use in `from_tuple`:
+ _MAP={
+ BaseTask.__name__:BaseTask,
+ SpeechDiarizationTask.__name__:SpeechDiarizationTask,
+ }
+
+ def__init__(self,task_type:Type[BaseTask],task_kwargs:dict=None):
+"""
+ Initialize the task creator.
+ :param task_type: The task type - a `BaseTask` subclass.
+ :param task_kwargs: Additional keyword arguments to pass to the to be created tasks.
+ """
+ self._task_type=task_type
+ self._task_kwargs=task_kwargsor{}
+
+
[docs]defcreate_task(self,audio_file:Path)->BaseTask:
+"""
+ Create a task with the given audio file.
+
+ :param audio_file: The audio file to assign to the task.
+
+ :returns: The created task.
+ """
+ returnself._task_type(audio_file=audio_file,**self._task_kwargs)
+
+
[docs]@classmethod
+ deffrom_tuple(cls,task_tuple:Tuple[str,dict])->BaseTask:
+"""
+ Create a task from a tuple of the audio file name and the task kwargs.
+
+ :param task_tuple: The task tuple to create the task from.
+
+ :returns: The created task.
+ """
+ task_class,task_kwargs=task_tuple
+ returncls._MAP[task_class](**task_kwargs)
+
+
+
[docs]classVoiceActivityDetector:
+"""
+ A voice activity detection wrapper for the silero VAD model - https://github.com/snakers4/silero-vad.
+ """
+
+ def__init__(
+ self,
+ # Model loading kwargs:
+ use_onnx:bool=True,
+ force_onnx_cpu:bool=True,
+ # Detection kwargs:
+ threshold:float=0.5,
+ sampling_rate:int=16_000,
+ min_speech_duration_ms:int=250,
+ max_speech_duration_s:float=float("inf"),
+ min_silence_duration_ms:int=100,
+ window_size_samples:int=512,
+ speech_pad_ms:int=30,
+ return_seconds:bool=False,
+ per_channel:bool=False,
+ ):
+"""
+ Initialize the voice activity detector.
+
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise,
+ they will be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in
+ samples (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD
+ on each channel separately and return a list of timestamps per channel.
+ """
+ # Store configurations:
+ self._use_onnx=use_onnx
+ self._force_onnx_cpu=force_onnx_cpu
+ self._threshold=threshold
+ self._sampling_rate=sampling_rate
+ self._min_speech_duration_ms=min_speech_duration_ms
+ self._max_speech_duration_s=max_speech_duration_s
+ self._min_silence_duration_ms=min_silence_duration_ms
+ self._window_size_samples=window_size_samples
+ self._speech_pad_ms=speech_pad_ms
+ self._return_seconds=return_seconds
+ self._per_channel=per_channel
+
+ # Prepare the model variables
+ self._model:torch.Module=None
+ self._get_speech_timestamps:FunctionType=None
+
+
[docs]defload(self,force_reload:bool=True):
+"""
+ Load the VAD model.
+
+ :param force_reload: Whether to force reload the model even if it was already loaded. Default is True.
+ """
+ model,utils=torch.hub.load(
+ repo_or_dir="snakers4/silero-vad",
+ model="silero_vad",
+ force_reload=force_reload,
+ onnx=self._use_onnx,
+ force_onnx_cpu=self._force_onnx_cpu,
+ )
+ self._model=model
+ (
+ self._get_speech_timestamps,
+ _,# save_audio,
+ _,# read_audio,
+ _,# VADIterator,
+ _,# collect_chunks
+ )=utils
+
+
[docs]defdetect_voice(
+ self,
+ audio_file:Path,
+ )->Union[List[Dict[str,int]],List[List[Dict[str,int]]]]:
+"""
+ Infer the audio through the VAD model and return the speech timestamps.
+
+ :param audio_file: The audio file to infer.
+
+ :returns: The speech timestamps in the audio. A list of timestamps where each timestamp is a dictionary with the
+ following keys:
+
+ * "start": The start sample index of the speech in the audio.
+ * "end": The end sample index of the speech in the audio.
+
+ If `per_channel` is True, a list of timestamps per channel will be returned.
+ """
+ # Cast to a numpy array:
+ audio=self._read_audio(audio_file)
+
+ # Detect speech:
+ ifnotself._per_channel:
+ returnself._get_speech_timestamps(
+ audio,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+
+ # Per channel:
+ speech_timestamps=[]
+ forchannelinaudio:
+ speech_timestamps.append(
+ self._get_speech_timestamps(
+ channel,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+ )
+
+ returnspeech_timestamps
+
+ def_read_audio(
+ self,
+ path:Path,
+ )->torch.Tensor:
+"""
+ Read the audio from the given path and return it as a tensor.
+
+ :param path: The path to the audio file.
+
+ :returns: The audio as a tensor.
+ """
+ # Read the audio:
+ audio,sampling_rate=torchaudio.load(str(path))
+
+ # Check if the audio is stereo and if so, convert it to mono (only if not per channel):
+ ifaudio.size(0)>1andnotself._per_channel:
+ audio=audio.mean(dim=0,keepdim=True)
+
+ # Resample the audio if needed:
+ ifsampling_rate!=self._sampling_rate:
+ transform=torchaudio.transforms.Resample(
+ orig_freq=sampling_rate,new_freq=self._sampling_rate
+ )
+ audio=transform(audio)
+
+ # Return the audio (squeeze if not per channel):
+ returnaudioifself._per_channelelseaudio.squeeze(0)
+
+
+#: The value to send into multiprocessing queues to stop the process:
+_MULTIPROCESSING_STOP_MARK="STOP"
+
+
+def_multiprocessing_complete_tasks(
+ vad_init_kwargs:dict,tasks_queue:Queue,results_queue:Queue
+):
+"""
+ Complete the tasks in the given queue and put the results in the given results queue. The function will stop when
+ the given tasks queue will receive the stop mark. It is aimed to be used with multiprocessing as a process.
+
+ :param vad_init_kwargs: The VAD initialization kwargs.
+ :param tasks_queue: A queue to get the tasks from.
+ :param results_queue: A queue to put the results in.
+ """
+ # Initialize and load the VAD:
+ vad=VoiceActivityDetector(**vad_init_kwargs)
+ vad.load(force_reload=False)
+
+ # Start listening to the tasks queue:
+ whileTrue:
+ # Get the task:
+ task:Tuple[str,dict]=tasks_queue.get()
+ iftask==_MULTIPROCESSING_STOP_MARK:
+ break
+ try:
+ # Create the task:
+ task=TaskCreator.from_tuple(task_tuple=task)
+ # Run the file through the VAD:
+ speech_timestamps=vad.detect_voice(audio_file=task.audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Build the result:
+ result=(False,task.get_result())
+ exceptExceptionasexception:
+ # Build the error:
+ result=(True,(task.audio_file.name,str(exception)))
+ # Collect the result / error:
+ results_queue.put(result)
+
+ # Mark the end of the tasks:
+ results_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+
+# Get the global logger:
+try:
+ importmlrun
+
+ _LOGGER=mlrun.get_or_create_ctx("silero_vad").logger
+exceptModuleNotFoundError:
+ _LOGGER=logging.getLogger()
+
+
+
[docs]defdetect_voice(
+ # Input kwargs:
+ data_path:Union[str,Path,List[Union[str,Path]]],
+ # Model loading kwargs:
+ use_onnx:bool=True,
+ force_onnx_cpu:bool=True,
+ # Detection kwargs:
+ threshold:float=0.5,
+ sampling_rate:int=16_000,
+ min_speech_duration_ms:int=250,
+ max_speech_duration_s:float=float("inf"),
+ min_silence_duration_ms:int=100,
+ window_size_samples:int=512,
+ speech_pad_ms:int=30,
+ return_seconds:bool=False,
+ per_channel:bool=False,
+ # Other kwargs:
+ use_multiprocessing:int=0,
+ verbose:bool=False,
+):
+"""
+ Perform voice activity detection on given audio files using the silero VAD model -
+ https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
+ VAD timestamps dictionaries as value.
+
+ For example::
+
+ {
+ "file_1.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ "file_2.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in samples
+ (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD on
+ each channel separately and return a list of timestamps per channel.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global_LOGGER
+
+ # Get the input audio files to transcribe:
+ ifverbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files=_get_audio_files(data_path=data_path)
+ ifverbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs={
+ "use_onnx":use_onnx,
+ "force_onnx_cpu":force_onnx_cpu,
+ "threshold":threshold,
+ "sampling_rate":sampling_rate,
+ "min_speech_duration_ms":min_speech_duration_ms,
+ "max_speech_duration_s":max_speech_duration_s,
+ "min_silence_duration_ms":min_silence_duration_ms,
+ "window_size_samples":window_size_samples,
+ "speech_pad_ms":speech_pad_ms,
+ "return_seconds":return_seconds,
+ "per_channel":per_channel,
+ }
+
+ # Create the task creator:
+ task_creator=TaskCreator(task_type=BaseTask)
+
+ # Run the transcription:
+ ifuse_multiprocessing:
+ results=_parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results=_run(
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return_process_results(results=results,verbose=verbose)
+
+
+
[docs]defdiarize(
+ # Input / Output kwargs:
+ data_path:Union[str,Path,List[Union[str,Path]]],
+ # Model loading kwargs:
+ use_onnx:bool=True,
+ force_onnx_cpu:bool=True,
+ # Detection kwargs:
+ threshold:float=0.5,
+ sampling_rate:int=16_000,
+ min_speech_duration_ms:int=250,
+ max_speech_duration_s:float=float("inf"),
+ min_silence_duration_ms:int=100,
+ window_size_samples:int=512,
+ speech_pad_ms:int=30,
+ # Diarization kwargs:
+ speaker_labels:List[str]=None,
+ # Other kwargs:
+ use_multiprocessing:int=0,
+ verbose:bool=False,
+):
+"""
+ Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
+ The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
+ end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ For example::
+
+ {
+ "file_1.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ "file_2.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be
+ named "speaker_0", "speaker_1", etc.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global_LOGGER
+
+ # Get the input audio files to transcribe:
+ ifverbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files=_get_audio_files(data_path=data_path)
+ ifverbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs={
+ "use_onnx":use_onnx,
+ "force_onnx_cpu":force_onnx_cpu,
+ "threshold":threshold,
+ "sampling_rate":sampling_rate,
+ "min_speech_duration_ms":min_speech_duration_ms,
+ "max_speech_duration_s":max_speech_duration_s,
+ "min_silence_duration_ms":min_silence_duration_ms,
+ "window_size_samples":window_size_samples,
+ "speech_pad_ms":speech_pad_ms,
+ "return_seconds":True,
+ "per_channel":True,
+ }
+
+ # Create the task creator:
+ task_creator=TaskCreator(
+ task_type=SpeechDiarizationTask,task_kwargs={"speaker_labels":speaker_labels}
+ )
+
+ # Run the transcription:
+ ifuse_multiprocessing:
+ results=_parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results=_run(
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return_process_results(results=results,verbose=verbose)
+
+
+def_get_audio_files(
+ data_path:Union[Path,str,list],
+)->List[Path]:
+"""
+ Get the audio files from the data path. If a path to a directory is given, all files in the directory will be
+ collected.
+
+ :param data_path: The data path to collect the audio files from.
+
+ :returns: The audio files list.
+ """
+ # Check if given a list of paths:
+ ifisinstance(data_path,list):
+ audio_files=[]
+ forpathindata_path:
+ audio_files.extend(_get_audio_files(data_path=path))
+ returnaudio_files
+
+ # Check if given a single string path to cast it to a `pathlib.Path`:
+ ifisinstance(data_path,str):
+ data_path=Path(data_path).absolute()
+
+ # Check if the path is of a directory or a file:
+ ifdata_path.is_dir():
+ # Get all files inside the directory:
+ audio_files=list(data_path.glob("*.*"))
+ elifdata_path.is_file():
+ audio_files=[data_path]
+ else:
+ raiseValueError(
+ f"Unrecognized data path. The parameter `data_path` must be a valid path to either a directory path or a "
+ f"file. Given: {str(data_path)} "
+ )
+
+ returnaudio_files
+
+
+def_run(
+ audio_files:List[Path],
+ description:str,
+ vad_init_kwargs:dict,
+ task_creator:TaskCreator,
+ verbose:bool,
+)->List[Tuple[bool,Tuple[str,list]]]:
+"""
+ Load a VAD and use it to complete the tasks that will be created on the provided files using the given task creator.
+
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD:
+ vad=VoiceActivityDetector(**vad_init_kwargs)
+ ifverbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad.load()
+ ifverbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Run the VAD on the audio files and collect the results:
+ results=[]
+ foraudio_fileintqdm(
+ audio_files,
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=notverbose,
+ ):
+ try:
+ # Create the task:
+ task=task_creator.create_task(audio_file=audio_file)
+ # Run the file through the VAD:
+ speech_timestamps=vad.detect_voice(audio_file=audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Collect the result:
+ results.append((False,task.get_result()))
+ exceptExceptionasexception:
+ # Collect the error:
+ results.append((True,(audio_file.name,str(exception))))
+
+ returnresults
+
+
+def_parallel_run(
+ n_workers:int,
+ audio_files:List[Path],
+ description:str,
+ vad_init_kwargs:dict,
+ task_creator:TaskCreator,
+ verbose:bool,
+)->List[Tuple[bool,Tuple[str,list]]]:
+"""
+ Run multiple VAD workers with multiprocessing to complete the tasks that will be created on the provided files using
+ the given task creator.
+
+ :param n_workers: The number of workers to use.
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD (download once, and it will be loaded then per process later on):
+ ifverbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad=VoiceActivityDetector(**vad_init_kwargs)
+ vad.load()
+ ifverbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Check the number of workers:
+ ifn_workers>len(audio_files):
+ _LOGGER.warning(
+ f"The number of workers ({n_workers}) is larger than the number of audio files ({len(audio_files)}). "
+ f"Setting the number of workers to {len(audio_files)}."
+ )
+ n_workers=len(audio_files)
+
+ # Initialize the multiprocessing queues:
+ tasks_queue=Queue()
+ results_queue=Queue()
+
+ # Initialize the multiprocessing processes:
+ task_completion_processes=[
+ Process(
+ target=_multiprocessing_complete_tasks,
+ kwargs={
+ "vad_init_kwargs":vad_init_kwargs,
+ "tasks_queue":tasks_queue,
+ "results_queue":results_queue,
+ },
+ )
+ for_inrange(n_workers)
+ ]
+
+ # Start the multiprocessing processes:
+ forpintask_completion_processes:
+ p.start()
+
+ # Put the tasks in the queue:
+ foraudio_fileinaudio_files:
+ tasks_queue.put(task_creator.create_task(audio_file=audio_file).to_tuple())
+
+ # Put the stop marks in the queue:
+ for_inrange(n_workers):
+ tasks_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+ # Collect the results:
+ results=[]
+ stop_marks_counter=0
+ withtqdm(
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=notverbose,
+ )asprogressbar:
+ whileTrue:
+ # Get a result from the queue:
+ result:Tuple[bool,Tuple[str,list]]=results_queue.get()
+ ifresult==_MULTIPROCESSING_STOP_MARK:
+ stop_marks_counter+=1
+ ifstop_marks_counter==n_workers:
+ break
+ else:
+ # Collect the result:
+ results.append(result)
+ progressbar.update(1)
+
+ # Wait for the processes to finish:
+ forpintask_completion_processes:
+ p.join()
+
+ returnresults
+
+
+def_process_results(
+ results:List[Tuple[bool,Tuple[str,list]]],verbose:bool
+)->Tuple[dict,dict]:
+"""
+ Process the results of the tasks.
+
+ :param results: The results to process.
+ :param verbose: Verbosity.
+
+ :returns: The processed results as a tuple of successes and errors.
+ """
+ ifverbose:
+ _LOGGER.info("Summarizing the results.")
+ successes={}
+ errors={}
+ foris_error,resultinresults:
+ ifis_error:
+ errors[result[0]]=result[1]
+ else:
+ successes[result[0]]=result[1]
+ ifverbose:
+ _LOGGER.info(f"Done ({len(successes)}/{len(successes)+len(errors)})\n")
+
+ returnsuccesses,errors
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/silero_vad/1.2.0/static/source.html b/functions/development/silero_vad/1.2.0/static/source.html
new file mode 100644
index 00000000..d4fba18f
--- /dev/null
+++ b/functions/development/silero_vad/1.2.0/static/source.html
@@ -0,0 +1,869 @@
+
+
+
+
+
+
+
+
+
+
+ Source
+
+
+
+
+
+
+# Copyright 2024 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+from multiprocessing import Process, Queue
+from pathlib import Path
+from types import FunctionType
+from typing import Dict, List, Tuple, Type, Union
+
+import torch
+import torchaudio
+from tqdm import tqdm
+
+
+class BaseTask:
+ """
+ A base class for a task to complete after VAD.
+ """
+
+ def __init__(self, audio_file: Path):
+ """
+ Initialize the base task.
+
+ :param audio_file: The audio file assigned to the task.
+ """
+ # Store the audio file:
+ self._audio_file = audio_file
+
+ # Prepare the result:
+ self._result = None
+
+ @property
+ def audio_file(self) -> Path:
+ """
+ Get the audio file of the task.
+
+ :returns: The audio file of the task.
+ """
+ return self._audio_file
+
+ def do_task(
+ self, speech_timestamps: Union[List[Dict[str, int]], List[List[Dict[str, int]]]]
+ ):
+ """
+ Do the task on the given speech timestamps. The base task will simply save the speech timestamps as the result.
+
+ :param speech_timestamps: The speech timestamps to do the task on as outputted from the VAD.
+ """
+ self._result = speech_timestamps
+
+ def get_result(self) -> Tuple[str, list]:
+ """
+ Get the result of the task. A tuple of the audio file name and the result.
+
+ :returns: The result of the task.
+ """
+ return self._audio_file.name, self._result
+
+ def to_tuple(self) -> Tuple[str, dict]:
+ """
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ return self.__class__.__name__, {"audio_file": self._audio_file}
+
+
+class SpeechDiarizationTask(BaseTask):
+ """
+ A speech diarization task. The task will diarize the VAD speech timestamps into speakers.
+ """
+
+ def __init__(self, audio_file: Path, speaker_labels: List[str]):
+ """
+ Initialize the speech diarization task.
+
+ :param audio_file: The audio file assigned to the task.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be named
+ "speaker_0", "speaker_1", etc.
+ """
+ super().__init__(audio_file=audio_file)
+ self._speaker_labels = speaker_labels
+
+ def do_task(self, speech_timestamps: List[List[Dict[str, int]]]):
+ """
+ Do the task on the given speech timestamps. The task will diarize the VAD speech timestamps into speakers.
+
+ :param speech_timestamps: The speech timestamps per channel to do the task on as outputted from the VAD.
+ """
+ # Get the speaker labels (set default if not given):
+ speaker_labels = self._speaker_labels or [
+ f"speaker_{i}" for i in range(len(speech_timestamps))
+ ]
+
+ # Diarize - organize the speech timestamps into a single list of speakers and sort it by start time:
+ speech_diarization = [
+ (speech_timestamp["start"], speech_timestamp["end"], speaker_label)
+ for speaker_label, channel_speech_timestamps in zip(
+ speaker_labels, speech_timestamps
+ )
+ for speech_timestamp in channel_speech_timestamps
+ ]
+ speech_diarization.sort()
+ self._result = speech_diarization
+
+ def to_tuple(self) -> Tuple[str, dict]:
+ """
+ Convert the task to a tuple to reconstruct it later (used for multiprocessing to pass in queue).
+
+ :returns: The converted task.
+ """
+ task_class, task_kwargs = super().to_tuple()
+ return task_class, {**task_kwargs, "speaker_labels": self._speaker_labels}
+
+
+class TaskCreator:
+ """
+ A task creator to create different tasks to run after the VAD.
+ """
+
+ #: A map from task class name to task class to use in `from_tuple`:
+ _MAP = {
+ BaseTask.__name__: BaseTask,
+ SpeechDiarizationTask.__name__: SpeechDiarizationTask,
+ }
+
+ def __init__(self, task_type: Type[BaseTask], task_kwargs: dict = None):
+ """
+ Initialize the task creator.
+ :param task_type: The task type - a `BaseTask` subclass.
+ :param task_kwargs: Additional keyword arguments to pass to the to be created tasks.
+ """
+ self._task_type = task_type
+ self._task_kwargs = task_kwargs or {}
+
+ def create_task(self, audio_file: Path) -> BaseTask:
+ """
+ Create a task with the given audio file.
+
+ :param audio_file: The audio file to assign to the task.
+
+ :returns: The created task.
+ """
+ return self._task_type(audio_file=audio_file, **self._task_kwargs)
+
+ @classmethod
+ def from_tuple(cls, task_tuple: Tuple[str, dict]) -> BaseTask:
+ """
+ Create a task from a tuple of the audio file name and the task kwargs.
+
+ :param task_tuple: The task tuple to create the task from.
+
+ :returns: The created task.
+ """
+ task_class, task_kwargs = task_tuple
+ return cls._MAP[task_class](**task_kwargs)
+
+
+class VoiceActivityDetector:
+ """
+ A voice activity detection wrapper for the silero VAD model - https://github.com/snakers4/silero-vad.
+ """
+
+ def __init__(
+ self,
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ return_seconds: bool = False,
+ per_channel: bool = False,
+ ):
+ """
+ Initialize the voice activity detector.
+
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise,
+ they will be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before
+ separating it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in
+ samples (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD
+ on each channel separately and return a list of timestamps per channel.
+ """
+ # Store configurations:
+ self._use_onnx = use_onnx
+ self._force_onnx_cpu = force_onnx_cpu
+ self._threshold = threshold
+ self._sampling_rate = sampling_rate
+ self._min_speech_duration_ms = min_speech_duration_ms
+ self._max_speech_duration_s = max_speech_duration_s
+ self._min_silence_duration_ms = min_silence_duration_ms
+ self._window_size_samples = window_size_samples
+ self._speech_pad_ms = speech_pad_ms
+ self._return_seconds = return_seconds
+ self._per_channel = per_channel
+
+ # Prepare the model variables
+ self._model: torch.Module = None
+ self._get_speech_timestamps: FunctionType = None
+
+ def load(self, force_reload: bool = True):
+ """
+ Load the VAD model.
+
+ :param force_reload: Whether to force reload the model even if it was already loaded. Default is True.
+ """
+ model, utils = torch.hub.load(
+ repo_or_dir="snakers4/silero-vad",
+ model="silero_vad",
+ force_reload=force_reload,
+ onnx=self._use_onnx,
+ force_onnx_cpu=self._force_onnx_cpu,
+ )
+ self._model = model
+ (
+ self._get_speech_timestamps,
+ _, # save_audio,
+ _, # read_audio,
+ _, # VADIterator,
+ _, # collect_chunks
+ ) = utils
+
+ def detect_voice(
+ self,
+ audio_file: Path,
+ ) -> Union[List[Dict[str, int]], List[List[Dict[str, int]]]]:
+ """
+ Infer the audio through the VAD model and return the speech timestamps.
+
+ :param audio_file: The audio file to infer.
+
+ :returns: The speech timestamps in the audio. A list of timestamps where each timestamp is a dictionary with the
+ following keys:
+
+ * "start": The start sample index of the speech in the audio.
+ * "end": The end sample index of the speech in the audio.
+
+ If `per_channel` is True, a list of timestamps per channel will be returned.
+ """
+ # Cast to a numpy array:
+ audio = self._read_audio(audio_file)
+
+ # Detect speech:
+ if not self._per_channel:
+ return self._get_speech_timestamps(
+ audio,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+
+ # Per channel:
+ speech_timestamps = []
+ for channel in audio:
+ speech_timestamps.append(
+ self._get_speech_timestamps(
+ channel,
+ self._model,
+ threshold=self._threshold,
+ min_speech_duration_ms=self._min_speech_duration_ms,
+ max_speech_duration_s=self._max_speech_duration_s,
+ min_silence_duration_ms=self._min_silence_duration_ms,
+ speech_pad_ms=self._speech_pad_ms,
+ sampling_rate=self._sampling_rate,
+ window_size_samples=self._window_size_samples,
+ return_seconds=self._return_seconds,
+ )
+ )
+
+ return speech_timestamps
+
+ def _read_audio(
+ self,
+ path: Path,
+ ) -> torch.Tensor:
+ """
+ Read the audio from the given path and return it as a tensor.
+
+ :param path: The path to the audio file.
+
+ :returns: The audio as a tensor.
+ """
+ # Read the audio:
+ audio, sampling_rate = torchaudio.load(str(path))
+
+ # Check if the audio is stereo and if so, convert it to mono (only if not per channel):
+ if audio.size(0) > 1 and not self._per_channel:
+ audio = audio.mean(dim=0, keepdim=True)
+
+ # Resample the audio if needed:
+ if sampling_rate != self._sampling_rate:
+ transform = torchaudio.transforms.Resample(
+ orig_freq=sampling_rate, new_freq=self._sampling_rate
+ )
+ audio = transform(audio)
+
+ # Return the audio (squeeze if not per channel):
+ return audio if self._per_channel else audio.squeeze(0)
+
+
+#: The value to send into multiprocessing queues to stop the process:
+_MULTIPROCESSING_STOP_MARK = "STOP"
+
+
+def _multiprocessing_complete_tasks(
+ vad_init_kwargs: dict, tasks_queue: Queue, results_queue: Queue
+):
+ """
+ Complete the tasks in the given queue and put the results in the given results queue. The function will stop when
+ the given tasks queue will receive the stop mark. It is aimed to be used with multiprocessing as a process.
+
+ :param vad_init_kwargs: The VAD initialization kwargs.
+ :param tasks_queue: A queue to get the tasks from.
+ :param results_queue: A queue to put the results in.
+ """
+ # Initialize and load the VAD:
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ vad.load(force_reload=False)
+
+ # Start listening to the tasks queue:
+ while True:
+ # Get the task:
+ task: Tuple[str, dict] = tasks_queue.get()
+ if task == _MULTIPROCESSING_STOP_MARK:
+ break
+ try:
+ # Create the task:
+ task = TaskCreator.from_tuple(task_tuple=task)
+ # Run the file through the VAD:
+ speech_timestamps = vad.detect_voice(audio_file=task.audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Build the result:
+ result = (False, task.get_result())
+ except Exception as exception:
+ # Build the error:
+ result = (True, (task.audio_file.name, str(exception)))
+ # Collect the result / error:
+ results_queue.put(result)
+
+ # Mark the end of the tasks:
+ results_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+
+# Get the global logger:
+try:
+ import mlrun
+
+ _LOGGER = mlrun.get_or_create_ctx("silero_vad").logger
+except ModuleNotFoundError:
+ _LOGGER = logging.getLogger()
+
+
+def detect_voice(
+ # Input kwargs:
+ data_path: Union[str, Path, List[Union[str, Path]]],
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ return_seconds: bool = False,
+ per_channel: bool = False,
+ # Other kwargs:
+ use_multiprocessing: int = 0,
+ verbose: bool = False,
+):
+ """
+ Perform voice activity detection on given audio files using the silero VAD model -
+ https://github.com/snakers4/silero-vad. The end result is a dictionary with the file names as keys and their
+ VAD timestamps dictionaries as value.
+
+ For example::
+
+ {
+ "file_1.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ "file_2.wav": [
+ {"start": 0, "end": 16000},
+ {"start": 16000, "end": 32000},
+ {"start": 32000, "end": 48000},
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param return_seconds: Whether return timestamps in seconds. False means to return timestamps in samples
+ (default - False).
+ :param per_channel: Whether to return timestamps per channel (default - False). This will run VAD on
+ each channel separately and return a list of timestamps per channel.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global _LOGGER
+
+ # Get the input audio files to transcribe:
+ if verbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files = _get_audio_files(data_path=data_path)
+ if verbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs = {
+ "use_onnx": use_onnx,
+ "force_onnx_cpu": force_onnx_cpu,
+ "threshold": threshold,
+ "sampling_rate": sampling_rate,
+ "min_speech_duration_ms": min_speech_duration_ms,
+ "max_speech_duration_s": max_speech_duration_s,
+ "min_silence_duration_ms": min_silence_duration_ms,
+ "window_size_samples": window_size_samples,
+ "speech_pad_ms": speech_pad_ms,
+ "return_seconds": return_seconds,
+ "per_channel": per_channel,
+ }
+
+ # Create the task creator:
+ task_creator = TaskCreator(task_type=BaseTask)
+
+ # Run the transcription:
+ if use_multiprocessing:
+ results = _parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results = _run(
+ audio_files=audio_files,
+ description="Detecting voice",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return _process_results(results=results, verbose=verbose)
+
+
+def diarize(
+ # Input / Output kwargs:
+ data_path: Union[str, Path, List[Union[str, Path]]],
+ # Model loading kwargs:
+ use_onnx: bool = True,
+ force_onnx_cpu: bool = True,
+ # Detection kwargs:
+ threshold: float = 0.5,
+ sampling_rate: int = 16_000,
+ min_speech_duration_ms: int = 250,
+ max_speech_duration_s: float = float("inf"),
+ min_silence_duration_ms: int = 100,
+ window_size_samples: int = 512,
+ speech_pad_ms: int = 30,
+ # Diarization kwargs:
+ speaker_labels: List[str] = None,
+ # Other kwargs:
+ use_multiprocessing: int = 0,
+ verbose: bool = False,
+):
+ """
+ Perform speech diarization on given audio files using the silero VAD model - https://github.com/snakers4/silero-vad.
+ The speech diarization is performed per channel so that each channel in the audio belong to a different speaker. The
+ end result is a dictionary with the file names as keys and their diarization as value. A diarization is a list
+ of tuples: (start, end, speaker_label).
+
+ For example::
+
+ {
+ "file_1.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ "file_2.wav": [
+ (0.0, 1.0, "speaker_0"),
+ (1.0, 2.0, "speaker_1"),
+ (2.0, 3.0, "speaker_0"),
+ ...
+ ],
+ ...
+ }
+
+
+ :param data_path: The path to the audio files to diarize. Can be a path to a single file, a path to a
+ directory or a list of paths to files.
+ :param use_onnx: Whether to use ONNX for inference. Default is True.
+ :param force_onnx_cpu: Whether to force ONNX to use CPU for inference. Default is True.
+ :param threshold: Speech threshold. Silero VAD outputs speech probabilities for each audio chunk,
+ probabilities ABOVE this value are considered as SPEECH. It is better to tune
+ this parameter for each dataset separately, but "lazy" 0.5 is pretty good for
+ most datasets.
+ :param sampling_rate: Currently, silero VAD models support 8000 and 16000 sample rates.
+ :param min_speech_duration_ms: Final speech chunks shorter min_speech_duration_ms are thrown out.
+ :param max_speech_duration_s: Maximum duration of speech chunks in seconds. Chunks longer than
+ `max_speech_duration_s` will be split at the timestamp of the last silence that
+ lasts more than 100ms (if any), to prevent aggressive cutting. Otherwise, they will
+ be split aggressively just before max_speech_duration_s.
+ :param min_silence_duration_ms: In the end of each speech chunk wait for min_silence_duration_ms before separating
+ it.
+ :param window_size_samples: Audio chunks of window_size_samples size are fed to the silero VAD model.
+
+ WARNING! Silero VAD models were trained using 512, 1024, 1536 samples for 16000
+ sample rate and 256, 512, 768 samples for 8000 sample rate. Values other than
+ these may affect model performance!
+ :param speech_pad_ms: Final speech chunks are padded by speech_pad_ms each side.
+ :param speaker_labels: The speaker labels to use for the diarization. If not given, the speakers will be
+ named "speaker_0", "speaker_1", etc.
+ :param use_multiprocessing: The number of workers to use for multiprocessing. If 0, no multiprocessing will
+ be used. Default is 0.
+ :param verbose: Verbosity.
+ """
+ global _LOGGER
+
+ # Get the input audio files to transcribe:
+ if verbose:
+ _LOGGER.info("Collecting audio files.")
+ audio_files = _get_audio_files(data_path=data_path)
+ if verbose:
+ _LOGGER.info(f"Collected {len(audio_files)} audio files.")
+
+ # Initialize the transcription pipeline:
+ vad_init_kwargs = {
+ "use_onnx": use_onnx,
+ "force_onnx_cpu": force_onnx_cpu,
+ "threshold": threshold,
+ "sampling_rate": sampling_rate,
+ "min_speech_duration_ms": min_speech_duration_ms,
+ "max_speech_duration_s": max_speech_duration_s,
+ "min_silence_duration_ms": min_silence_duration_ms,
+ "window_size_samples": window_size_samples,
+ "speech_pad_ms": speech_pad_ms,
+ "return_seconds": True,
+ "per_channel": True,
+ }
+
+ # Create the task creator:
+ task_creator = TaskCreator(
+ task_type=SpeechDiarizationTask, task_kwargs={"speaker_labels": speaker_labels}
+ )
+
+ # Run the transcription:
+ if use_multiprocessing:
+ results = _parallel_run(
+ n_workers=use_multiprocessing,
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+ else:
+ results = _run(
+ audio_files=audio_files,
+ description="Diarizing",
+ vad_init_kwargs=vad_init_kwargs,
+ task_creator=task_creator,
+ verbose=verbose,
+ )
+
+ # Process the results:
+ return _process_results(results=results, verbose=verbose)
+
+
+def _get_audio_files(
+ data_path: Union[Path, str, list],
+) -> List[Path]:
+ """
+ Get the audio files from the data path. If a path to a directory is given, all files in the directory will be
+ collected.
+
+ :param data_path: The data path to collect the audio files from.
+
+ :returns: The audio files list.
+ """
+ # Check if given a list of paths:
+ if isinstance(data_path, list):
+ audio_files = []
+ for path in data_path:
+ audio_files.extend(_get_audio_files(data_path=path))
+ return audio_files
+
+ # Check if given a single string path to cast it to a `pathlib.Path`:
+ if isinstance(data_path, str):
+ data_path = Path(data_path).absolute()
+
+ # Check if the path is of a directory or a file:
+ if data_path.is_dir():
+ # Get all files inside the directory:
+ audio_files = list(data_path.glob("*.*"))
+ elif data_path.is_file():
+ audio_files = [data_path]
+ else:
+ raise ValueError(
+ f"Unrecognized data path. The parameter `data_path` must be a valid path to either a directory path or a "
+ f"file. Given: {str(data_path)} "
+ )
+
+ return audio_files
+
+
+def _run(
+ audio_files: List[Path],
+ description: str,
+ vad_init_kwargs: dict,
+ task_creator: TaskCreator,
+ verbose: bool,
+) -> List[Tuple[bool, Tuple[str, list]]]:
+ """
+ Load a VAD and use it to complete the tasks that will be created on the provided files using the given task creator.
+
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD:
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ if verbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad.load()
+ if verbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Run the VAD on the audio files and collect the results:
+ results = []
+ for audio_file in tqdm(
+ audio_files,
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=not verbose,
+ ):
+ try:
+ # Create the task:
+ task = task_creator.create_task(audio_file=audio_file)
+ # Run the file through the VAD:
+ speech_timestamps = vad.detect_voice(audio_file=audio_file)
+ # Complete the task:
+ task.do_task(speech_timestamps=speech_timestamps)
+ # Collect the result:
+ results.append((False, task.get_result()))
+ except Exception as exception:
+ # Collect the error:
+ results.append((True, (audio_file.name, str(exception))))
+
+ return results
+
+
+def _parallel_run(
+ n_workers: int,
+ audio_files: List[Path],
+ description: str,
+ vad_init_kwargs: dict,
+ task_creator: TaskCreator,
+ verbose: bool,
+) -> List[Tuple[bool, Tuple[str, list]]]:
+ """
+ Run multiple VAD workers with multiprocessing to complete the tasks that will be created on the provided files using
+ the given task creator.
+
+ :param n_workers: The number of workers to use.
+ :param audio_files: The audio files to use.
+ :param description: The description to use for the progress bar.
+ :param vad_init_kwargs: The VAD initialization keyword arguments.
+ :param task_creator: The task creator to use to create the tasks.
+ :param verbose: Verbosity.
+
+ :returns: The collected results.
+ """
+ # Load the VAD (download once, and it will be loaded then per process later on):
+ if verbose:
+ _LOGGER.info(f"Loading the VAD model.")
+ vad = VoiceActivityDetector(**vad_init_kwargs)
+ vad.load()
+ if verbose:
+ _LOGGER.info("VAD model loaded.")
+
+ # Check the number of workers:
+ if n_workers > len(audio_files):
+ _LOGGER.warning(
+ f"The number of workers ({n_workers}) is larger than the number of audio files ({len(audio_files)}). "
+ f"Setting the number of workers to {len(audio_files)}."
+ )
+ n_workers = len(audio_files)
+
+ # Initialize the multiprocessing queues:
+ tasks_queue = Queue()
+ results_queue = Queue()
+
+ # Initialize the multiprocessing processes:
+ task_completion_processes = [
+ Process(
+ target=_multiprocessing_complete_tasks,
+ kwargs={
+ "vad_init_kwargs": vad_init_kwargs,
+ "tasks_queue": tasks_queue,
+ "results_queue": results_queue,
+ },
+ )
+ for _ in range(n_workers)
+ ]
+
+ # Start the multiprocessing processes:
+ for p in task_completion_processes:
+ p.start()
+
+ # Put the tasks in the queue:
+ for audio_file in audio_files:
+ tasks_queue.put(task_creator.create_task(audio_file=audio_file).to_tuple())
+
+ # Put the stop marks in the queue:
+ for _ in range(n_workers):
+ tasks_queue.put(_MULTIPROCESSING_STOP_MARK)
+
+ # Collect the results:
+ results = []
+ stop_marks_counter = 0
+ with tqdm(
+ desc=description,
+ unit="file",
+ total=len(audio_files),
+ disable=not verbose,
+ ) as progressbar:
+ while True:
+ # Get a result from the queue:
+ result: Tuple[bool, Tuple[str, list]] = results_queue.get()
+ if result == _MULTIPROCESSING_STOP_MARK:
+ stop_marks_counter += 1
+ if stop_marks_counter == n_workers:
+ break
+ else:
+ # Collect the result:
+ results.append(result)
+ progressbar.update(1)
+
+ # Wait for the processes to finish:
+ for p in task_completion_processes:
+ p.join()
+
+ return results
+
+
+def _process_results(
+ results: List[Tuple[bool, Tuple[str, list]]], verbose: bool
+) -> Tuple[dict, dict]:
+ """
+ Process the results of the tasks.
+
+ :param results: The results to process.
+ :param verbose: Verbosity.
+
+ :returns: The processed results as a tuple of successes and errors.
+ """
+ if verbose:
+ _LOGGER.info("Summarizing the results.")
+ successes = {}
+ errors = {}
+ for is_error, result in results:
+ if is_error:
+ errors[result[0]] = result[1]
+ else:
+ successes[result[0]] = result[1]
+ if verbose:
+ _LOGGER.info(f"Done ({len(successes)}/{len(successes) + len(errors)})\n")
+
+ return successes, errors
+
+
+
+
+
\ No newline at end of file
diff --git a/functions/development/silero_vad/latest/src/function.yaml b/functions/development/silero_vad/latest/src/function.yaml
index 75d1ce0c..0b4ad422 100644
--- a/functions/development/silero_vad/latest/src/function.yaml
+++ b/functions/development/silero_vad/latest/src/function.yaml
@@ -2,12 +2,12 @@ kind: job
metadata:
name: silero-vad
tag: ''
- hash: bc0ad5572cc391fcdc93baaee48e1ef949a7984d
+ hash: 61b7a70c167b7819481fdabf9350fc6fa344d2f5
project: ''
labels:
author: guyl
categories:
- - Deep Learning
+ - deep-learning
- PyTorch
- Audio
spec:
@@ -34,8 +34,9 @@ spec:
outputs:
- doc: The audio file of the task.
type: Path
- default: ''
lineno: 43
+ has_varargs: false
+ has_kwargs: false
do_task:
name: do_task
doc: Do the task on the given speech timestamps. The task will diarize the VAD
@@ -46,9 +47,10 @@ spec:
type: List[List[Dict[str, int]]]
doc: The speech timestamps per channel to do the task on as outputted from
the VAD.
- outputs:
- - default: ''
+ outputs: []
lineno: 94
+ has_varargs: false
+ has_kwargs: false
get_result:
name: get_result
doc: Get the result of the task. A tuple of the audio file name and the result.
@@ -56,8 +58,10 @@ spec:
- name: self
outputs:
- doc: The result of the task.
- default: ''
+ type: Tuple[str, list]
lineno: 61
+ has_varargs: false
+ has_kwargs: false
to_tuple:
name: to_tuple
doc: Convert the task to a tuple to reconstruct it later (used for multiprocessing
@@ -66,8 +70,10 @@ spec:
- name: self
outputs:
- doc: The converted task.
- default: ''
+ type: Tuple[str, dict]
lineno: 116
+ has_varargs: false
+ has_kwargs: false
create_task:
name: create_task
doc: Create a task with the given audio file.
@@ -79,8 +85,9 @@ spec:
outputs:
- doc: The created task.
type: BaseTask
- default: ''
lineno: 146
+ has_varargs: false
+ has_kwargs: false
from_tuple:
name: from_tuple
doc: Create a task from a tuple of the audio file name and the task kwargs.
@@ -92,8 +99,9 @@ spec:
outputs:
- doc: The created task.
type: BaseTask
- default: ''
lineno: 157
+ has_varargs: false
+ has_kwargs: false
load:
name: load
doc: Load the VAD model.
@@ -104,9 +112,10 @@ spec:
doc: Whether to force reload the model even if it was already loaded. Default
is True.
default: true
- outputs:
- - default: ''
+ outputs: []
lineno: 234
+ has_varargs: false
+ has_kwargs: false
detect_voice:
name: detect_voice
doc: "Perform voice activity detection on given audio files using the silero\
@@ -186,9 +195,10 @@ spec:
type: bool
doc: Verbosity.
default: false
- outputs:
- - default: ''
+ outputs: []
lineno: 393
+ has_varargs: false
+ has_kwargs: false
diarize:
name: diarize
doc: "Perform speech diarization on given audio files using the silero VAD model\
@@ -264,9 +274,10 @@ spec:
type: bool
doc: Verbosity.
default: false
- outputs:
- - default: ''
+ outputs: []
lineno: 517
+ has_varargs: false
+ has_kwargs: false
description: Silero VAD (Voice Activity Detection) functions.
default_handler: detect_voice
disable_auto_mount: false
diff --git a/functions/development/silero_vad/latest/src/item.yaml b/functions/development/silero_vad/latest/src/item.yaml
index 6f85a4c7..17c8eb62 100644
--- a/functions/development/silero_vad/latest/src/item.yaml
+++ b/functions/development/silero_vad/latest/src/item.yaml
@@ -1,8 +1,8 @@
apiVersion: v1
categories:
- - Deep Learning
- - PyTorch
- - Audio
+- deep-learning
+- PyTorch
+- Audio
description: Silero VAD (Voice Activity Detection) functions.
doc: ''
example: silero_vad.ipynb
@@ -22,9 +22,9 @@ spec:
image: mlrun/mlrun
kind: job
requirements:
- - torch
- - torchaudio
- - tqdm
- - onnxruntime
+ - torch
+ - torchaudio
+ - tqdm
+ - onnxruntime
url: ''
-version: 1.1.0
+version: 1.2.0
diff --git a/functions/development/silero_vad/latest/static/function.html b/functions/development/silero_vad/latest/static/function.html
index 6cc50a8e..0f90fdfc 100644
--- a/functions/development/silero_vad/latest/static/function.html
+++ b/functions/development/silero_vad/latest/static/function.html
@@ -19,12 +19,12 @@
metadata:
name: silero-vad
tag: ''
- hash: bc0ad5572cc391fcdc93baaee48e1ef949a7984d
+ hash: 61b7a70c167b7819481fdabf9350fc6fa344d2f5
project: ''
labels:
author: guyl
categories:
- - Deep Learning
+ - deep-learning
- PyTorch
- Audio
spec:
@@ -51,8 +51,9 @@
outputs:
- doc: The audio file of the task.
type: Path
- default: ''
lineno: 43
+ has_varargs: false
+ has_kwargs: false
do_task:
name: do_task
doc: Do the task on the given speech timestamps. The task will diarize the VAD
@@ -63,9 +64,10 @@
type: List[List[Dict[str, int]]]
doc: The speech timestamps per channel to do the task on as outputted from
the VAD.
- outputs:
- - default: ''
+ outputs: []
lineno: 94
+ has_varargs: false
+ has_kwargs: false
get_result:
name: get_result
doc: Get the result of the task. A tuple of the audio file name and the result.
@@ -73,8 +75,10 @@
- name: self
outputs:
- doc: The result of the task.
- default: ''
+ type: Tuple[str, list]
lineno: 61
+ has_varargs: false
+ has_kwargs: false
to_tuple:
name: to_tuple
doc: Convert the task to a tuple to reconstruct it later (used for multiprocessing
@@ -83,8 +87,10 @@
- name: self
outputs:
- doc: The converted task.
- default: ''
+ type: Tuple[str, dict]
lineno: 116
+ has_varargs: false
+ has_kwargs: false
create_task:
name: create_task
doc: Create a task with the given audio file.
@@ -96,8 +102,9 @@
outputs:
- doc: The created task.
type: BaseTask
- default: ''
lineno: 146
+ has_varargs: false
+ has_kwargs: false
from_tuple:
name: from_tuple
doc: Create a task from a tuple of the audio file name and the task kwargs.
@@ -109,8 +116,9 @@
outputs:
- doc: The created task.
type: BaseTask
- default: ''
lineno: 157
+ has_varargs: false
+ has_kwargs: false
load:
name: load
doc: Load the VAD model.
@@ -121,9 +129,10 @@
doc: Whether to force reload the model even if it was already loaded. Default
is True.
default: true
- outputs:
- - default: ''
+ outputs: []
lineno: 234
+ has_varargs: false
+ has_kwargs: false
detect_voice:
name: detect_voice
doc: "Perform voice activity detection on given audio files using the silero\
@@ -203,9 +212,10 @@
type: bool
doc: Verbosity.
default: false
- outputs:
- - default: ''
+ outputs: []
lineno: 393
+ has_varargs: false
+ has_kwargs: false
diarize:
name: diarize
doc: "Perform speech diarization on given audio files using the silero VAD model\
@@ -281,9 +291,10 @@
type: bool
doc: Verbosity.
default: false
- outputs:
- - default: ''
+ outputs: []
lineno: 517
+ has_varargs: false
+ has_kwargs: false
description: Silero VAD (Voice Activity Detection) functions.
default_handler: detect_voice
disable_auto_mount: false
diff --git a/functions/development/silero_vad/latest/static/item.html b/functions/development/silero_vad/latest/static/item.html
index 0c322d0a..5c26352e 100644
--- a/functions/development/silero_vad/latest/static/item.html
+++ b/functions/development/silero_vad/latest/static/item.html
@@ -17,9 +17,9 @@
apiVersion: v1
categories:
- - Deep Learning
- - PyTorch
- - Audio
+- deep-learning
+- PyTorch
+- Audio
description: Silero VAD (Voice Activity Detection) functions.
doc: ''
example: silero_vad.ipynb
@@ -39,12 +39,12 @@
image: mlrun/mlrun
kind: job
requirements:
- - torch
- - torchaudio
- - tqdm
- - onnxruntime
+ - torch
+ - torchaudio
+ - tqdm
+ - onnxruntime
url: ''
-version: 1.1.0
+version: 1.2.0
diff --git a/functions/development/tags.json b/functions/development/tags.json
index 75c58820..85af01d0 100644
--- a/functions/development/tags.json
+++ b/functions/development/tags.json
@@ -1 +1 @@
-{"kind": ["nuclio:serving", "serving", "dask", "nuclio", "job"], "categories": ["model-serving", "data-analysis", "machine-learning", "data-preparation", "data-generation", "GenAI", "deep-learning", "model-training", "utils", "Deep Learning", "NLP", "data-validation", "etl", "monitoring", "model-testing", "PyTorch", "feature-store", "Audio", "Huggingface"]}
\ No newline at end of file
+{"kind": ["nuclio", "job", "nuclio:serving", "dask", "serving"], "categories": ["GenAI", "deep-learning", "Huggingface", "PyTorch", "model-testing", "data-generation", "machine-learning", "model-serving", "data-preparation", "utils", "model-training", "feature-store", "NLP", "monitoring", "data-analysis", "data-validation", "Audio", "etl"]}
\ No newline at end of file