add nemo 2.2.1 源码

.gitignore

@@ -1,10 +1,18 @@
 # log and data files
 # common_voice_11_0/
+# nemo/
+nemotron-speech-streaming-en-0.6b/
 common_voice_11_0/audio/
 common_voice_11_0/ja/
-# data/common_voice_11_0/audio/
+common_voice_11_0/eo/
+data/common_voice_11_0/audio/
 data/common_voice_11_0/ja/
+data/common_voice_11_0/eo/
 Common Voice Scripted Speech 25.0 - Japanese/
+results/
+results__ja/
+data__ja/
+transcripts.json
 *.model
 *.pkl
 #*.ipynb
@@ -198,3 +206,4 @@ node_modules/
 bot_server.*
 audio_logs/
 eval_results/
+

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "git.ignoreLimitWarning": true
+}

common_voice_ja_25372057.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4cc63eaf4bfd5822ce2f862963aed974b5011029298f57375c65f344bb0ffccb
+size 109484

data/common_voice_11_0/transcript/ja/dev.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d55fb0f1620a80f4c60d37da95199b11119f3d2508ad9b3f900dc30a8ebc0c3d
-size 1107150
+oid sha256:43446a3f7fd7f418258a9f8cc170b632ab146e59e53c630ae8ea857eb7d8817d
+size 296

data/common_voice_11_0/transcript/ja/invalidated.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c51e1ec9c5c3fd2eb8a3c91673f63ac2a9d137329c15d1e9864b8fe0c10ba12f
-size 638492
+oid sha256:43446a3f7fd7f418258a9f8cc170b632ab146e59e53c630ae8ea857eb7d8817d
+size 296

data/common_voice_11_0/transcript/ja/other.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:24a4e2ce8306879f866124ede472a074c4ea7dab0cdb40f731aef965d74eef73
-size 283969
+oid sha256:43446a3f7fd7f418258a9f8cc170b632ab146e59e53c630ae8ea857eb7d8817d
+size 296

data/common_voice_11_0/transcript/ja/test.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ae722b5a68c5e56ca667aced836061e2375de26301eb0285b5b1f0a76efb0b93
-size 1122112
+oid sha256:43446a3f7fd7f418258a9f8cc170b632ab146e59e53c630ae8ea857eb7d8817d
+size 296

data/common_voice_11_0/transcript/ja/train.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34b534ad4c3c0e76ad416095cefed0d8cc73c4a0273c1e16331a0f2f2cdee416
-size 1729826
+oid sha256:6daf7d3220aad6fcf8636361aca0d5365d8720a917a61a37e6e86c286485666a
+size 297

examples/asr/asr_ctc/speech_to_text_ctc_bpe.py

@@ -64,6 +64,10 @@ https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/results.ht
 
 """
 
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..')))
+
 import lightning.pytorch as pl
 from omegaconf import OmegaConf
 

examples/asr/asr_eou/speech_to_text_rnnt_eou_train.py

@@ -76,6 +76,10 @@ CUDA_VISIBLE_DEVICES=0 python $SCRIPT \
 
 """
 
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..')))
+
 from dataclasses import is_dataclass
 from typing import Optional
 

examples/asr/asr_streaming_inference/README.md

@@ -9,4 +9,4 @@ Beyond streaming ASR, the script also supports:
 * **Streaming Speech Translation (requires vLLM installation)**
 * **Word-level and Segment-level Output**
 
-All related configurations can be found in the `../conf/asr_streaming_inference/` directory.
+All related configurations can be found in the `../conf/asr_streaming_inference/` directory.

harvard_16k.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa5b415ee7caf6606a04f739a9fe8490fae3d726157cc080060426ead07dfb8b
+size 587496

nemo/__init__.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+
+from nemo.package_info import (
+    __contact_emails__,
+    __contact_names__,
+    __description__,
+    __download_url__,
+    __homepage__,
+    __keywords__,
+    __license__,
+    __package_name__,
+    __repository_url__,
+    __shortversion__,
+    __version__,
+)

nemo/collections/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.

nemo/collections/asr/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr import data, losses, models, modules
+from nemo.package_info import __version__
+
+# Set collection version equal to NeMo version.
+__version = __version__
+
+# Authorship.
+__author__ = "NVIDIA Corporation"
+
+# Set collection name.
+__description__ = "Automatic Speech Recognition collection"

nemo/collections/asr/data/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.

nemo/collections/asr/data/audio_to_ctm_dataset.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, List, Tuple
+
+from nemo.collections.asr.data.audio_to_text_dataset import ASRPredictionWriter
+from nemo.utils import logging
+
+
+@dataclass
+class FrameCtmUnit:
+    """A container class for one CTM unit with start and length countable in frames.
+    """
+
+    label: str
+    start_frame: int
+    length: int
+    probability: float
+
+    def __repr__(self) -> str:
+        return f"{self.label}\t({self.probability:1.3f}): [{self.start_frame:6d}, {self.length:6d}]"
+
+    @property
+    def end_frame(self):
+        return self.start_frame + self.length
+
+    def to_ctm_str(self, time_per_frame: int) -> str:
+        """Represents the data as part of the CTM line.
+
+        The CTM line format is
+            <utterance_name> <channel> <start_time> <duration> <label_str> <probability>
+        This method prepares the last four entities."""
+        return f"{self.start_frame * time_per_frame :.3f} {self.length * time_per_frame :.3f} {self.label} {self.probability :1.3f}"
+
+
+class ASRCTMPredictionWriter(ASRPredictionWriter):
+    def __init__(self, dataset, output_file: str, output_ctm_dir: str, time_per_frame: float):
+        super().__init__(dataset, output_file)
+        self.output_ctm_dir = output_ctm_dir
+        self.time_per_frame = time_per_frame
+        os.makedirs(self.output_ctm_dir, exist_ok=True)
+
+    def write_ctm(self, name, filepath, frameCtmUnits):
+        with open(filepath, "tw", encoding="utf-8") as f:
+            for unit in frameCtmUnits:
+                f.write(f"{name} 1 {unit.to_ctm_str(self.time_per_frame)}\n")
+
+    def write_on_batch_end(
+        self,
+        trainer,
+        pl_module: 'LightningModule',
+        prediction: Tuple[int, List[FrameCtmUnit]],
+        batch_indices: List[int],
+        batch: Any,
+        batch_idx: int,
+        dataloader_idx: int,
+    ):
+        for sample_id, units in prediction:
+            sample = self.dataset.get_manifest_sample(sample_id)
+            with_ctm = True
+            if len(units) == 0:
+                logging.warning(
+                    f"""Do not producing CTM output for item `{sample.audio_file}`.
+                    Check if text is empty or if duration is too short: `{sample.text_raw}`, {sample.duration}"""
+                )
+                with_ctm = False
+            item = {}
+            item["audio_filepath"] = sample.audio_file
+            item["duration"] = sample.duration
+            item["text"] = sample.text_raw
+            if with_ctm:
+                utt_name = Path(sample.audio_file).stem
+                ctm_filepath = os.path.join(self.output_ctm_dir, utt_name) + ".ctm"
+                self.write_ctm(utt_name, ctm_filepath, units)
+                item["ctm_filepath"] = ctm_filepath
+            else:
+                item["ctm_filepath"] = ""
+            self.outf.write(json.dumps(item) + "\n")
+            self.samples_num += 1
+        return

nemo/collections/asr/data/audio_to_diar_label.py

@@ -0,0 +1,1379 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 os
+from collections import OrderedDict
+from statistics import mode
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+
+from nemo.collections.asr.parts.utils.offline_clustering import get_argmin_mat
+from nemo.collections.asr.parts.utils.speaker_utils import convert_rttm_line, get_subsegments, prepare_split_data
+from nemo.collections.common.parts.preprocessing.collections import (
+    DiarizationSpeechLabel,
+    EndtoEndDiarizationSpeechLabel,
+)
+from nemo.core.classes import Dataset
+from nemo.core.neural_types import AudioSignal, EncodedRepresentation, LengthsType, NeuralType, ProbsType
+from nemo.utils import logging
+
+
+def get_scale_mapping_list(uniq_timestamps):
+    """
+    Call get_argmin_mat function to find the index of the non-base-scale segment that is closest to the
+    given base-scale segment. For each scale and each segment, a base-scale segment is assigned.
+
+    Args:
+        uniq_timestamps: (dict)
+            The dictionary containing embeddings, timestamps and multiscale weights.
+            If uniq_timestamps contains only one scale, single scale diarization is performed.
+
+    Returns:
+        scale_mapping_argmat (torch.tensor):
+
+            The element at the m-th row and the n-th column of the scale mapping matrix indicates the (m+1)-th scale
+            segment index which has the closest center distance with (n+1)-th segment in the base scale.
+
+            - Example:
+                `scale_mapping_argmat[2][101] = 85`
+
+            In the above example, the code snippet means that 86-th segment in the 3rd scale (python index is 2) is
+            mapped to the 102-th segment in the base scale. Thus, the longer segments bound to have more repeating
+            numbers since multiple base scale segments (since the base scale has the shortest length) fall into the
+            range of the longer segments. At the same time, each row contains N numbers of indices where N is number
+            of segments in the base-scale (i.e., the finest scale).
+    """
+    timestamps_in_scales = []
+    for key, val in uniq_timestamps['scale_dict'].items():
+        timestamps_in_scales.append(torch.tensor(val['time_stamps']))
+    session_scale_mapping_list = get_argmin_mat(timestamps_in_scales)
+    scale_mapping_argmat = [[] for _ in range(len(uniq_timestamps['scale_dict'].keys()))]
+    for scale_idx in range(len(session_scale_mapping_list)):
+        scale_mapping_argmat[scale_idx] = session_scale_mapping_list[scale_idx]
+    scale_mapping_argmat = torch.stack(scale_mapping_argmat)
+    return scale_mapping_argmat
+
+
+def extract_seg_info_from_rttm(rttm_lines, mapping_dict=None, target_spks=None):
+    """
+    Get RTTM lines containing speaker labels, start time and end time. target_spks contains two targeted
+    speaker indices for creating groundtruth label files. Only speakers in target_spks variable will be
+    included in the output lists.
+
+    Args:
+        uniq_id (str):
+            Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
+        rttm_lines (list):
+            List containing RTTM lines in str format.
+        mapping_dict (dict):
+            Mapping between the estimated speakers and the speakers in the ground-truth annotation.
+            `mapping_dict` variable is only provided when the inference mode is running in sequence-eval mode.
+            Sequence eval mode uses the mapping between the estimated speakers and the speakers
+            in ground-truth annotation.
+    Returns:
+        rttm_tup (tuple):
+            Tuple containing lists of start time, end time and speaker labels.
+
+    """
+    stt_list, end_list, speaker_list, pairwise_infer_spks = [], [], [], []
+    if target_spks:
+        inv_map = {v: k for k, v in mapping_dict.items()}
+        for spk_idx in target_spks:
+            spk_str = f'speaker_{spk_idx}'
+            if spk_str in inv_map:
+                pairwise_infer_spks.append(inv_map[spk_str])
+    for rttm_line in rttm_lines:
+        start, end, speaker = convert_rttm_line(rttm_line)
+        if target_spks is None or speaker in pairwise_infer_spks:
+            end_list.append(end)
+            stt_list.append(start)
+            speaker_list.append(speaker)
+    rttm_tup = (stt_list, end_list, speaker_list)
+    return rttm_tup
+
+
+def assign_frame_level_spk_vector(rttm_timestamps, round_digits, frame_per_sec, target_spks, min_spks=2):
+    """
+    Create a multi-dimensional vector sequence containing speaker timestamp information in RTTM.
+    The unit-length is the frame shift length of the acoustic feature. The feature-level annotations
+    `fr_level_target` will later be converted to base-segment level diarization label.
+
+    Args:
+        rttm_timestamps (list):
+            List containing start and end time for each speaker segment label.
+            `stt_list`, `end_list` and `speaker_list` are contained.
+        frame_per_sec (int):
+            Number of feature frames per second. This quantity is determined by
+            `window_stride` variable in preprocessing module.
+        target_spks (tuple):
+            Speaker indices that are generated from combinations.
+            If there are only one or two speakers,
+            only a single `target_spks` variable is generated.
+
+    Returns:
+        fr_level_target (torch.tensor):
+            Tensor containing label for each feature level frame.
+    """
+    stt_list, end_list, speaker_list = rttm_timestamps
+    if len(speaker_list) == 0:
+        return None
+    else:
+        sorted_speakers = sorted(list(set(speaker_list)))
+        total_fr_len = int(max(end_list) * (10**round_digits))
+        spk_num = max(len(sorted_speakers), min_spks)
+        speaker_mapping_dict = {rttm_key: x_int for x_int, rttm_key in enumerate(sorted_speakers)}
+        fr_level_target = torch.zeros(total_fr_len, spk_num)
+
+        # If RTTM is not provided, then there is no speaker mapping dict in target_spks.
+        # Thus, return a zero-filled tensor as a placeholder.
+        for count, (stt, end, spk_rttm_key) in enumerate(zip(stt_list, end_list, speaker_list)):
+            stt, end = round(stt, round_digits), round(end, round_digits)
+            spk = speaker_mapping_dict[spk_rttm_key]
+            stt_fr, end_fr = int(round(stt, 2) * frame_per_sec), int(round(end, round_digits) * frame_per_sec)
+            fr_level_target[stt_fr:end_fr, spk] = 1
+        return fr_level_target
+
+
+def get_subsegments_to_timestamps(
+    subsegments: List[Tuple[float, float]], feat_per_sec: int = 100, max_end_ts: float = None, decimals=2
+):
+    """
+    Convert subsegment timestamps to scale timestamps by multiplying with the feature rate (`feat_per_sec`)
+    and rounding. Segment is consisted of many subsegments and sugsegments are equivalent to `frames`
+    in end-to-end speaker diarization models.
+
+    Args:
+        subsegments (List[Tuple[float, float]]):
+            A list of tuples where each tuple contains the start and end times of a subsegment
+            (frames in end-to-end models).
+            >>> subsegments = [[t0_start, t0_duration], [t1_start, t1_duration],..., [tN_start, tN_duration]]
+        feat_per_sec (int, optional):
+            The number of feature frames per second. Defaults to 100.
+        max_end_ts (float, optional):
+            The maximum end timestamp to clip the results. If None, no clipping is applied. Defaults to None.
+        decimals (int, optional):
+            The number of decimal places to round the timestamps. Defaults to 2.
+
+    Example:
+        Segments starting from 0.0 and ending at 69.2 seconds.
+        If hop-length is 0.08 and the subsegment (frame) length is 0.16 seconds,
+        there are 864 = (69.2 - 0.16)/0.08 + 1 subsegments (frames in end-to-end models) in this segment.
+        >>> subsegments = [[[0.0, 0.16], [0.08, 0.16], ..., [69.04, 0.16], [69.12, 0.08]]
+
+    Returns:
+        ts (torch.tensor):
+            A tensor containing the scaled and rounded timestamps for each subsegment.
+    """
+    seg_ts = (torch.tensor(subsegments) * feat_per_sec).float()
+    ts_round = torch.round(seg_ts, decimals=decimals)
+    ts = ts_round.long()
+    ts[:, 1] = ts[:, 0] + ts[:, 1]
+    if max_end_ts is not None:
+        ts = np.clip(ts, 0, int(max_end_ts * feat_per_sec))
+    return ts
+
+
+def extract_frame_info_from_rttm(offset, duration, rttm_lines, round_digits=3):
+    """
+    Extracts RTTM lines containing speaker labels, start time, and end time for a given audio segment.
+
+    Args:
+        uniq_id (str): Unique identifier for the audio file and corresponding RTTM file.
+        offset (float): The starting time offset for the segment of interest.
+        duration (float): The duration of the segment of interest.
+        rttm_lines (list): List of RTTM lines in string format.
+        round_digits (int, optional): Number of decimal places to round the start and end times. Defaults to 3.
+
+    Returns:
+        rttm_mat (tuple): A tuple containing lists of start times, end times, and speaker labels.
+        sess_to_global_spkids (dict): A mapping from session-specific speaker indices to global speaker identifiers.
+    """
+    rttm_stt, rttm_end = offset, offset + duration
+    stt_list, end_list, speaker_list, speaker_set = [], [], [], []
+    sess_to_global_spkids = dict()
+
+    for rttm_line in rttm_lines:
+        start, end, speaker = convert_rttm_line(rttm_line)
+
+        # Skip invalid RTTM lines where the start time is greater than the end time.
+        if start > end:
+            continue
+
+        # Check if the RTTM segment overlaps with the specified segment of interest.
+        if (end > rttm_stt and start < rttm_end) or (start < rttm_end and end > rttm_stt):
+            # Adjust the start and end times to fit within the segment of interest.
+            start, end = max(start, rttm_stt), min(end, rttm_end)
+        else:
+            continue
+
+        # Round the start and end times to the specified number of decimal places.
+        end_list.append(round(end, round_digits))
+        stt_list.append(round(start, round_digits))
+
+        # Assign a unique index to each speaker and maintain a mapping.
+        if speaker not in speaker_set:
+            speaker_set.append(speaker)
+        speaker_list.append(speaker_set.index(speaker))
+        sess_to_global_spkids.update({speaker_set.index(speaker): speaker})
+
+    rttm_mat = (stt_list, end_list, speaker_list)
+    return rttm_mat, sess_to_global_spkids
+
+
+def get_frame_targets_from_rttm(
+    rttm_timestamps: list,
+    offset: float,
+    duration: float,
+    round_digits: int,
+    feat_per_sec: int,
+    max_spks: int,
+):
+    """
+    Create a multi-dimensional vector sequence containing speaker timestamp information in RTTM.
+    The unit-length is the frame shift length of the acoustic feature. The feature-level annotations
+    `feat_level_target` will later be converted to base-segment level diarization label.
+
+    Args:
+        rttm_timestamps (list):
+            List containing start and end time for each speaker segment label.
+            stt_list, end_list and speaker_list are contained.
+        feat_per_sec (int):
+            Number of feature frames per second.
+            This quantity is determined by window_stride variable in preprocessing module.
+        target_spks (tuple):
+            Speaker indices that are generated from combinations. If there are only one or two speakers,
+            only a single target_spks variable is generated.
+
+    Returns:
+        feat_level_target (torch.tensor):
+            Tensor containing label for each feature level frame.
+    """
+    stt_list, end_list, speaker_list = rttm_timestamps
+    sorted_speakers = sorted(list(set(speaker_list)))
+    total_fr_len = int(duration * feat_per_sec)
+    if len(sorted_speakers) > max_spks:
+        logging.warning(
+            f"Number of speakers in RTTM file {len(sorted_speakers)} exceeds the maximum number of speakers: "
+            f"{max_spks}! Only {max_spks} first speakers remain, and this will affect frame metrics!"
+        )
+    feat_level_target = torch.zeros(total_fr_len, max_spks)
+    for count, (stt, end, spk_rttm_key) in enumerate(zip(stt_list, end_list, speaker_list)):
+        if end < offset or stt > offset + duration:
+            continue
+        stt, end = max(offset, stt), min(offset + duration, end)
+        spk = spk_rttm_key
+        if spk < max_spks:
+            stt_fr, end_fr = int((stt - offset) * feat_per_sec), int((end - offset) * feat_per_sec)
+            feat_level_target[stt_fr:end_fr, spk] = 1
+    return feat_level_target
+
+
+class _AudioMSDDTrainDataset(Dataset):
+    """
+    Dataset class that loads a json file containing paths to audio files,
+    RTTM files and number of speakers. This Dataset class is designed for
+    training or fine-tuning speaker embedding extractor and diarization decoder
+    at the same time.
+
+    Example:
+    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_0.rttm}
+    ...
+    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_n.rttm}
+
+    Args:
+        manifest_filepath (str):
+            Path to input manifest json files.
+        multiscale_args_dict (dict):
+            Dictionary containing the parameters for multiscale segmentation and clustering.
+        emb_dir (str):
+            Path to a temporary folder where segmentation information for embedding extraction is saved.
+        soft_label_thres (float):
+            Threshold that determines the label of each segment based on RTTM file information.
+        featurizer:
+            Featurizer instance for generating features from the raw waveform.
+        window_stride (float):
+            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
+        emb_batch_size (int):
+            Number of embedding vectors that are trained with attached computational graphs.
+        pairwise_infer (bool):
+            This variable should be True if dataloader is created for an inference task.
+        random_flip (bool):
+            If True, the two labels and input signals are randomly flipped per every epoch while training.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        output_types = {
+            "features": NeuralType(('B', 'T'), AudioSignal()),
+            "feature_length": NeuralType(('B'), LengthsType()),
+            "ms_seg_timestamps": NeuralType(('B', 'C', 'T', 'D'), LengthsType()),
+            "ms_seg_counts": NeuralType(('B', 'C'), LengthsType()),
+            "clus_label_index": NeuralType(('B', 'T'), LengthsType()),
+            "scale_mapping": NeuralType(('B', 'C', 'T'), LengthsType()),
+            "targets": NeuralType(('B', 'T', 'C'), ProbsType()),
+        }
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        multiscale_args_dict: str,
+        emb_dir: str,
+        soft_label_thres: float,
+        featurizer,
+        window_stride,
+        emb_batch_size,
+        pairwise_infer: bool,
+        random_flip: bool = True,
+        global_rank: int = 0,
+    ):
+        super().__init__()
+        self.collection = DiarizationSpeechLabel(
+            manifests_files=manifest_filepath.split(','),
+            emb_dict=None,
+            clus_label_dict=None,
+            pairwise_infer=pairwise_infer,
+        )
+        self.featurizer = featurizer
+        self.multiscale_args_dict = multiscale_args_dict
+        self.emb_dir = emb_dir
+        self.round_digits = 2
+        self.decim = 10**self.round_digits
+        self.soft_label_thres = soft_label_thres
+        self.pairwise_infer = pairwise_infer
+        self.max_spks = 2
+        self.frame_per_sec = int(1 / window_stride)
+        self.emb_batch_size = emb_batch_size
+        self.random_flip = random_flip
+        self.global_rank = global_rank
+        self.manifest_filepath = manifest_filepath
+        self.multiscale_timestamp_dict = prepare_split_data(
+            self.manifest_filepath,
+            self.emb_dir,
+            self.multiscale_args_dict,
+            self.global_rank,
+        )
+
+    def __len__(self):
+        return len(self.collection)
+
+    def assign_labels_to_longer_segs(self, uniq_id, base_scale_clus_label):
+        """
+        Assign the generated speaker labels from the base scale (the finest scale) to the longer scales.
+        This process is needed to get the cluster labels for each scale. The cluster labels are needed to
+        calculate the cluster-average speaker embedding for each scale.
+
+        Args:
+            uniq_id (str):
+                Unique sample ID for training.
+            base_scale_clus_label (torch.tensor):
+                Tensor variable containing the speaker labels for the base-scale segments.
+
+        Returns:
+            per_scale_clus_label (torch.tensor):
+                Tensor variable containing the speaker labels for each segment in each scale.
+                Note that the total length of the speaker label sequence differs over scale since
+                each scale has a different number of segments for the same session.
+
+            scale_mapping (torch.tensor):
+                Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
+                multiscale embeddings to form an input matrix for the MSDD model.
+        """
+        per_scale_clus_label = []
+        self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])
+        uniq_scale_mapping = get_scale_mapping_list(self.multiscale_timestamp_dict[uniq_id])
+        for scale_index in range(self.scale_n):
+            new_clus_label = []
+            scale_seq_len = len(self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_index]["time_stamps"])
+            for seg_idx in range(scale_seq_len):
+                if seg_idx in uniq_scale_mapping[scale_index]:
+                    seg_clus_label = mode(base_scale_clus_label[uniq_scale_mapping[scale_index] == seg_idx])
+                else:
+                    seg_clus_label = 0 if len(new_clus_label) == 0 else new_clus_label[-1]
+                new_clus_label.append(seg_clus_label)
+            per_scale_clus_label.extend(new_clus_label)
+        per_scale_clus_label = torch.tensor(per_scale_clus_label)
+        return per_scale_clus_label, uniq_scale_mapping
+
+    def get_diar_target_labels(self, uniq_id, sample, fr_level_target):
+        """
+        Convert frame-level diarization target variable into segment-level target variable.
+        Since the granularity is reduced from frame level (10ms) to segment level (100ms~500ms),
+        we need a threshold value, `soft_label_thres`, which determines the label of each segment
+        based on the overlap between a segment range (start and end time) and the frame-level target variable.
+
+        Args:
+            uniq_id (str):
+                Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
+            sample:
+                `DiarizationSpeechLabel` instance containing sample information such as
+                audio filepath and RTTM filepath.
+            fr_level_target (torch.tensor):
+                Tensor containing label for each feature-level frame.
+
+        Returns:
+            seg_target (torch.tensor):
+                Tensor containing binary speaker labels for base-scale segments.
+            base_clus_label (torch.tensor):
+                Representative speaker label for each segment. This variable only has one speaker label
+                for each base-scale segment.
+                -1 means that there is no corresponding speaker in the target_spks tuple.
+        """
+        seg_target_list, base_clus_label = [], []
+        self.scale_n = len(self.multiscale_timestamp_dict[uniq_id]['scale_dict'])
+        subseg_time_stamp_list = self.multiscale_timestamp_dict[uniq_id]["scale_dict"][self.scale_n - 1]["time_stamps"]
+        for seg_stt, seg_end in subseg_time_stamp_list:
+            seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)
+            soft_label_vec_sess = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (
+                seg_end_fr - seg_stt_fr
+            )
+            label_int_sess = torch.argmax(soft_label_vec_sess)
+            soft_label_vec = soft_label_vec_sess.unsqueeze(0)[:, sample.target_spks].squeeze()
+            if label_int_sess in sample.target_spks and torch.sum(soft_label_vec_sess) > 0:
+                label_int = sample.target_spks.index(label_int_sess)
+            else:
+                label_int = -1
+            label_vec = (soft_label_vec > self.soft_label_thres).float()
+            seg_target_list.append(label_vec.detach())
+            base_clus_label.append(label_int)
+        seg_target = torch.stack(seg_target_list)
+        base_clus_label = torch.tensor(base_clus_label)
+        return seg_target, base_clus_label
+
+    def parse_rttm_for_ms_targets(self, sample):
+        """
+        Generate target tensor variable by extracting groundtruth diarization labels from an RTTM file.
+        This function converts (start, end, speaker_id) format into base-scale (the finest scale) segment level
+        diarization label in a matrix form.
+
+        Example of seg_target:
+            [[0., 1.], [0., 1.], [1., 1.], [1., 0.], [1., 0.], ..., [0., 1.]]
+
+        Args:
+            sample:
+                `DiarizationSpeechLabel` instance containing sample information such as
+                audio filepath and RTTM filepath.
+            target_spks (tuple):
+                Speaker indices that are generated from combinations. If there are only one or two speakers,
+                only a single target_spks tuple is generated.
+
+        Returns:
+            clus_label_index (torch.tensor):
+                Groundtruth clustering label (cluster index for each segment) from RTTM files for training purpose.
+            seg_target  (torch.tensor):
+                Tensor variable containing hard-labels of speaker activity in each base-scale segment.
+            scale_mapping (torch.tensor):
+                Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
+                multiscale embeddings to form an input matrix for the MSDD model.
+
+        """
+        with open(sample.rttm_file, 'r') as file:
+            rttm_lines = file.readlines()
+        uniq_id = self.get_uniq_id_with_range(sample)
+        rttm_timestamps = extract_seg_info_from_rttm(rttm_lines)
+        fr_level_target = assign_frame_level_spk_vector(
+            rttm_timestamps, self.round_digits, self.frame_per_sec, target_spks=sample.target_spks
+        )
+        seg_target, base_clus_label = self.get_diar_target_labels(uniq_id, sample, fr_level_target)
+        clus_label_index, scale_mapping = self.assign_labels_to_longer_segs(uniq_id, base_clus_label)
+        return clus_label_index, seg_target, scale_mapping
+
+    def get_uniq_id_with_range(self, sample, deci=3):
+        """
+        Generate unique training sample ID from unique file ID, offset and duration. The start-end time added
+        unique ID is required for identifying the sample since multiple short audio samples are generated from a single
+        audio file. The start time and end time of the audio stream uses millisecond units if `deci=3`.
+
+        Args:
+            sample:
+                `DiarizationSpeechLabel` instance from collections.
+
+        Returns:
+            uniq_id (str):
+                Unique sample ID which includes start and end time of the audio stream.
+                Example: abc1001_3122_6458
+
+        """
+        bare_uniq_id = os.path.splitext(os.path.basename(sample.rttm_file))[0]
+        offset = str(int(round(sample.offset, deci) * pow(10, deci)))
+        endtime = str(int(round(sample.offset + sample.duration, deci) * pow(10, deci)))
+        uniq_id = f"{bare_uniq_id}_{offset}_{endtime}"
+        return uniq_id
+
+    def get_ms_seg_timestamps(self, sample):
+        """
+        Get start and end time of each diarization frame.
+
+        Args:
+            sample:
+                `DiarizationSpeechLabel` instance from preprocessing.collections
+        Returns:
+            ms_seg_timestamps (torch.tensor):
+                Tensor containing timestamps for each frame.
+            ms_seg_counts (torch.tensor):
+                Number of segments for each scale. This information is used for reshaping embedding batch
+                during forward propagation.
+        """
+        uniq_id = self.get_uniq_id_with_range(sample)
+        ms_seg_timestamps_list = []
+        max_seq_len = len(self.multiscale_timestamp_dict[uniq_id]["scale_dict"][self.scale_n - 1]["time_stamps"])
+        ms_seg_counts = [0 for _ in range(self.scale_n)]
+        for scale_idx in range(self.scale_n):
+            scale_ts_list = []
+            for k, (seg_stt, seg_end) in enumerate(
+                self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_idx]["time_stamps"]
+            ):
+                stt, end = (
+                    int((seg_stt - sample.offset) * self.frame_per_sec),
+                    int((seg_end - sample.offset) * self.frame_per_sec),
+                )
+                scale_ts_list.append(torch.tensor([stt, end]).detach())
+            ms_seg_counts[scale_idx] = len(
+                self.multiscale_timestamp_dict[uniq_id]["scale_dict"][scale_idx]["time_stamps"]
+            )
+            scale_ts = torch.stack(scale_ts_list)
+            scale_ts_padded = torch.cat([scale_ts, torch.zeros(max_seq_len - len(scale_ts_list), 2)], dim=0)
+            ms_seg_timestamps_list.append(scale_ts_padded.detach())
+        ms_seg_timestamps = torch.stack(ms_seg_timestamps_list)
+        ms_seg_counts = torch.tensor(ms_seg_counts)
+        return ms_seg_timestamps, ms_seg_counts
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+        if sample.offset is None:
+            sample.offset = 0
+        clus_label_index, targets, scale_mapping = self.parse_rttm_for_ms_targets(sample)
+        features = self.featurizer.process(sample.audio_file, offset=sample.offset, duration=sample.duration)
+        feature_length = torch.tensor(features.shape[0]).long()
+        ms_seg_timestamps, ms_seg_counts = self.get_ms_seg_timestamps(sample)
+        if self.random_flip:
+            torch.manual_seed(index)
+            flip = torch.cat([torch.randperm(self.max_spks), torch.tensor(-1).unsqueeze(0)])
+            clus_label_index, targets = flip[clus_label_index], targets[:, flip[: self.max_spks]]
+        return features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets
+
+
+class _AudioMSDDInferDataset(Dataset):
+    """
+    Dataset class that loads a json file containing paths to audio files,
+    RTTM files and number of speakers. This Dataset class is built for diarization inference and
+    evaluation. Speaker embedding sequences, segment timestamps, cluster-average speaker embeddings
+    are loaded from memory and fed into the dataloader.
+
+    Example:
+    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_0.rttm}
+    ...
+    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_n.rttm}
+
+    Args:
+        manifest_filepath (str):
+             Path to input manifest json files.
+        emb_dict (dict):
+            Dictionary containing cluster-average embeddings and speaker mapping information.
+        emb_seq (dict):
+            Dictionary containing multiscale speaker embedding sequence,
+            scale mapping and corresponding segment timestamps.
+        clus_label_dict (dict):
+            Subsegment-level (from base-scale) speaker labels from clustering results.
+        soft_label_thres (float):
+            A threshold that determines the label of each segment based on RTTM file information.
+        featurizer:
+            Featurizer instance for generating features from raw waveform.
+        seq_eval_mode (bool):
+            If True, F1 score will be calculated for each speaker pair during inference mode.
+        window_stride (float):
+            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
+        use_single_scale_clus (bool):
+            Use only one scale for clustering instead of using multiple scales of embeddings for clustering.
+        pairwise_infer (bool):
+            This variable should be True if dataloader is created for an inference task.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        output_types = OrderedDict(
+            {
+                "ms_emb_seq": NeuralType(('B', 'T', 'C', 'D'), SpectrogramType()),
+                "length": NeuralType(tuple('B'), LengthsType()),
+                "ms_avg_embs": NeuralType(('B', 'C', 'D', 'C'), EncodedRepresentation()),
+                "targets": NeuralType(('B', 'T', 'C'), ProbsType()),
+            }
+        )
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        emb_dict: Dict,
+        emb_seq: Dict,
+        clus_label_dict: Dict,
+        soft_label_thres: float,
+        seq_eval_mode: bool,
+        window_stride: float,
+        use_single_scale_clus: bool,
+        pairwise_infer: bool,
+    ):
+        super().__init__()
+        self.collection = DiarizationSpeechLabel(
+            manifests_files=manifest_filepath.split(','),
+            emb_dict=emb_dict,
+            clus_label_dict=clus_label_dict,
+            seq_eval_mode=seq_eval_mode,
+            pairwise_infer=pairwise_infer,
+        )
+        self.emb_dict = emb_dict
+        self.emb_seq = emb_seq
+        self.clus_label_dict = clus_label_dict
+        self.round_digits = 2
+        self.decim = 10**self.round_digits
+        self.frame_per_sec = int(1 / window_stride)
+        self.soft_label_thres = soft_label_thres
+        self.pairwise_infer = pairwise_infer
+        self.max_spks = 2
+        self.use_single_scale_clus = use_single_scale_clus
+        self.seq_eval_mode = seq_eval_mode
+
+    def __len__(self):
+        return len(self.collection)
+
+    def parse_rttm_multiscale(self, sample):
+        """
+        Generate target tensor variable by extracting groundtruth diarization labels from an RTTM file.
+        This function is only used when ``self.seq_eval_mode=True`` and RTTM files are provided. This function converts
+        (start, end, speaker_id) format into base-scale (the finest scale) segment level diarization label in a matrix
+        form to create target matrix.
+
+        Args:
+            sample:
+                DiarizationSpeechLabel instance containing sample information such as audio filepath and RTTM filepath.
+            target_spks (tuple):
+                Two Indices of targeted speakers for evaluation.
+                Example of target_spks: (2, 3)
+        Returns:
+            seg_target (torch.tensor):
+                Tensor variable containing hard-labels of speaker activity in each base-scale segment.
+        """
+        if sample.rttm_file is None:
+            raise ValueError(f"RTTM file is not provided for this sample {sample}")
+        rttm_lines = open(sample.rttm_file).readlines()
+        uniq_id = os.path.splitext(os.path.basename(sample.rttm_file))[0]
+        mapping_dict = self.emb_dict[max(self.emb_dict.keys())][uniq_id]['mapping']
+        rttm_timestamps = extract_seg_info_from_rttm(rttm_lines, mapping_dict, sample.target_spks)
+        fr_level_target = assign_frame_level_spk_vector(
+            rttm_timestamps, self.round_digits, self.frame_per_sec, sample.target_spks
+        )
+        seg_target = self.get_diar_target_labels_from_fr_target(uniq_id, fr_level_target)
+        return seg_target
+
+    def get_diar_target_labels_from_fr_target(self, uniq_id: str, fr_level_target: torch.Tensor) -> torch.Tensor:
+        """
+        Generate base-scale level binary diarization label from frame-level target matrix. For the given frame-level
+        speaker target matrix fr_level_target, we count the number of frames that belong to each speaker and calculate
+        ratios for each speaker into the `soft_label_vec` variable. Finally, `soft_label_vec` variable is compared
+        with `soft_label_thres` to determine whether a label vector should contain 0 or 1 for each speaker bin.
+        Note that seg_target variable has dimension of (number of base-scale segments x 2) dimension.
+
+        Example of seg_target:
+            [[0., 1.], [0., 1.], [1., 1.], [1., 0.], [1., 0.], ..., [0., 1.]]
+
+        Args:
+            uniq_id (str):
+                Unique file ID that refers to an input audio file and corresponding RTTM (Annotation) file.
+            fr_level_target (torch.tensor):
+                frame-level binary speaker annotation (1: exist 0: non-exist) generated from RTTM file.
+
+        Returns:
+            seg_target (torch.tensor):
+                Tensor variable containing binary hard-labels of speaker activity in each base-scale segment.
+
+        """
+        if fr_level_target is None:
+            return None
+        else:
+            seg_target_list = []
+            for seg_stt, seg_end, label_int in self.clus_label_dict[uniq_id]:
+                seg_stt_fr, seg_end_fr = int(seg_stt * self.frame_per_sec), int(seg_end * self.frame_per_sec)
+                soft_label_vec = torch.sum(fr_level_target[seg_stt_fr:seg_end_fr, :], axis=0) / (
+                    seg_end_fr - seg_stt_fr
+                )
+                label_vec = (soft_label_vec > self.soft_label_thres).int()
+                seg_target_list.append(label_vec)
+            seg_target = torch.stack(seg_target_list)
+            return seg_target
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+        if sample.offset is None:
+            sample.offset = 0
+
+        uniq_id = os.path.splitext(os.path.basename(sample.audio_file))[0]
+        scale_n = len(self.emb_dict.keys())
+        _avg_embs = torch.stack([self.emb_dict[scale_index][uniq_id]['avg_embs'] for scale_index in range(scale_n)])
+
+        if self.pairwise_infer:
+            avg_embs = _avg_embs[:, :, self.collection[index].target_spks]
+        else:
+            avg_embs = _avg_embs
+
+        if avg_embs.shape[2] > self.max_spks:
+            raise ValueError(
+                f" avg_embs.shape[2] {avg_embs.shape[2]} should be less than or equal to "
+                f"self.max_num_speakers {self.max_spks}"
+            )
+
+        feats = []
+        for scale_index in range(scale_n):
+            repeat_mat = self.emb_seq["session_scale_mapping"][uniq_id][scale_index]
+            feats.append(self.emb_seq[scale_index][uniq_id][repeat_mat, :])
+        feats_out = torch.stack(feats).permute(1, 0, 2)
+        feats_len = feats_out.shape[0]
+
+        if self.seq_eval_mode:
+            targets = self.parse_rttm_multiscale(sample)
+        else:
+            targets = torch.zeros(feats_len, 2).float()
+
+        return feats_out, feats_len, targets, avg_embs
+
+
+def _msdd_train_collate_fn(self, batch):
+    """
+    Collate batch of variables that are needed for raw waveform to diarization label training.
+    The following variables are included in training/validation batch:
+
+    Args:
+        batch (tuple):
+            Batch tuple containing the variables for the diarization training.
+    Returns:
+        features (torch.tensor):
+            Raw waveform samples (time series) loaded from the audio_filepath in the input manifest file.
+        feature lengths (time series sample length):
+            A list of lengths of the raw waveform samples.
+        ms_seg_timestamps (torch.tensor):
+            Matrix containing the start time and end time (timestamps) for each segment and each scale.
+            ms_seg_timestamps is needed for extracting acoustic features from raw waveforms.
+        ms_seg_counts (torch.tensor):
+            Matrix containing The number of segments for each scale. ms_seg_counts is necessary for reshaping
+            the input matrix for the MSDD model.
+        clus_label_index (torch.tensor):
+            Groundtruth Clustering label (cluster index for each segment) from RTTM files for training purpose.
+            clus_label_index is necessary for calculating cluster-average embedding.
+        scale_mapping (torch.tensor):
+            Matrix containing the segment indices of each scale. scale_mapping is necessary for reshaping the
+            multiscale embeddings to form an input matrix for the MSDD model.
+        targets (torch.tensor):
+            Groundtruth Speaker label for the given input embedding sequence.
+    """
+    packed_batch = list(zip(*batch))
+    features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets = packed_batch
+    features_list, feature_length_list = [], []
+    ms_seg_timestamps_list, ms_seg_counts_list, scale_clus_label_list, scale_mapping_list, targets_list = (
+        [],
+        [],
+        [],
+        [],
+        [],
+    )
+
+    max_raw_feat_len = max([x.shape[0] for x in features])
+    max_target_len = max([x.shape[0] for x in targets])
+    max_total_seg_len = max([x.shape[0] for x in clus_label_index])
+
+    for feat, feat_len, ms_seg_ts, ms_seg_ct, scale_clus, scl_map, tgt in batch:
+        seq_len = tgt.shape[0]
+        pad_feat = (0, max_raw_feat_len - feat_len)
+        pad_tgt = (0, 0, 0, max_target_len - seq_len)
+        pad_sm = (0, max_target_len - seq_len)
+        pad_ts = (0, 0, 0, max_target_len - seq_len)
+        pad_sc = (0, max_total_seg_len - scale_clus.shape[0])
+        padded_feat = torch.nn.functional.pad(feat, pad_feat)
+        padded_tgt = torch.nn.functional.pad(tgt, pad_tgt)
+        padded_sm = torch.nn.functional.pad(scl_map, pad_sm)
+        padded_ms_seg_ts = torch.nn.functional.pad(ms_seg_ts, pad_ts)
+        padded_scale_clus = torch.nn.functional.pad(scale_clus, pad_sc)
+
+        features_list.append(padded_feat)
+        feature_length_list.append(feat_len.clone().detach())
+        ms_seg_timestamps_list.append(padded_ms_seg_ts)
+        ms_seg_counts_list.append(ms_seg_ct.clone().detach())
+        scale_clus_label_list.append(padded_scale_clus)
+        scale_mapping_list.append(padded_sm)
+        targets_list.append(padded_tgt)
+
+    features = torch.stack(features_list)
+    feature_length = torch.stack(feature_length_list)
+    ms_seg_timestamps = torch.stack(ms_seg_timestamps_list)
+    clus_label_index = torch.stack(scale_clus_label_list)
+    ms_seg_counts = torch.stack(ms_seg_counts_list)
+    scale_mapping = torch.stack(scale_mapping_list)
+    targets = torch.stack(targets_list)
+    return features, feature_length, ms_seg_timestamps, ms_seg_counts, clus_label_index, scale_mapping, targets
+
+
+def _msdd_infer_collate_fn(self, batch):
+    """
+    Collate batch of feats (speaker embeddings), feature lengths, target label sequences
+    and cluster-average embeddings.
+
+    Args:
+        batch (tuple):
+            Batch tuple containing feats, feats_len, targets and ms_avg_embs.
+    Returns:
+        feats (torch.tensor):
+            Collated speaker embedding with unified length.
+        feats_len (torch.tensor):
+            The actual length of each embedding sequence without zero padding.
+        targets (torch.tensor):
+            Groundtruth Speaker label for the given input embedding sequence.
+        ms_avg_embs (torch.tensor):
+            Cluster-average speaker embedding vectors.
+    """
+
+    packed_batch = list(zip(*batch))
+    feats, feats_len, targets, ms_avg_embs = packed_batch
+    feats_list, flen_list, targets_list, ms_avg_embs_list = [], [], [], []
+    max_audio_len = max(feats_len)
+    max_target_len = max([x.shape[0] for x in targets])
+
+    for feature, feat_len, target, ivector in batch:
+        flen_list.append(feat_len)
+        ms_avg_embs_list.append(ivector)
+        if feat_len < max_audio_len:
+            pad_a = (0, 0, 0, 0, 0, max_audio_len - feat_len)
+            pad_t = (0, 0, 0, max_target_len - target.shape[0])
+            padded_feature = torch.nn.functional.pad(feature, pad_a)
+            padded_target = torch.nn.functional.pad(target, pad_t)
+            feats_list.append(padded_feature)
+            targets_list.append(padded_target)
+        else:
+            targets_list.append(target.clone().detach())
+            feats_list.append(feature.clone().detach())
+
+    feats = torch.stack(feats_list)
+    feats_len = torch.tensor(flen_list)
+    targets = torch.stack(targets_list)
+    ms_avg_embs = torch.stack(ms_avg_embs_list)
+    return feats, feats_len, targets, ms_avg_embs
+
+
+class AudioToSpeechMSDDTrainDataset(_AudioMSDDTrainDataset):
+    """
+    Dataset class that loads a json file containing paths to audio files,
+    rttm files and number of speakers. This Dataset class is designed for
+    training or fine-tuning speaker embedding extractor and diarization decoder
+    at the same time.
+
+    Example:
+    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_0.rttm}
+    ...
+    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_n.rttm}
+
+    Args:
+        manifest_filepath (str):
+            Path to input manifest json files.
+        multiscale_args_dict (dict):
+            Dictionary containing the parameters for multiscale segmentation and clustering.
+        emb_dir (str):
+            Path to a temporary folder where segmentation information for embedding extraction is saved.
+        soft_label_thres (float):
+            A threshold that determines the label of each segment based on RTTM file information.
+        featurizer:
+            Featurizer instance for generating features from the raw waveform.
+        window_stride (float):
+            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
+        emb_batch_size (int):
+            Number of embedding vectors that are trained with attached computational graphs.
+        pairwise_infer (bool):
+            This variable should be True if dataloader is created for an inference task.
+    """
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        multiscale_args_dict: Dict,
+        emb_dir: str,
+        soft_label_thres: float,
+        featurizer,
+        window_stride,
+        emb_batch_size,
+        pairwise_infer: bool,
+        global_rank: int,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            multiscale_args_dict=multiscale_args_dict,
+            emb_dir=emb_dir,
+            soft_label_thres=soft_label_thres,
+            featurizer=featurizer,
+            window_stride=window_stride,
+            emb_batch_size=emb_batch_size,
+            pairwise_infer=pairwise_infer,
+            global_rank=global_rank,
+        )
+
+    def msdd_train_collate_fn(self, batch):
+        """Collate batch of audio features, feature lengths, target label sequences for training."""
+        return _msdd_train_collate_fn(self, batch)
+
+
+class AudioToSpeechMSDDInferDataset(_AudioMSDDInferDataset):
+    """
+    Dataset class that loads a json file containing paths to audio files,
+    rttm files and number of speakers. The created labels are used for diarization inference.
+
+    Example:
+    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_0.rttm}
+    ...
+    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_n.rttm}
+
+    Args:
+        manifest_filepath (str):
+            Path to input manifest json files.
+        emb_dict (dict):
+            Dictionary containing cluster-average embeddings and speaker mapping information.
+        emb_seq (dict):
+            Dictionary containing multiscale speaker embedding sequence, scale mapping
+            and corresponding segment timestamps.
+        clus_label_dict (dict):
+            Subsegment-level (from base-scale) speaker labels from clustering results.
+        soft_label_thres (float):
+            Threshold that determines speaker labels of segments depending on the overlap
+            with groundtruth speaker timestamps.
+        featurizer:
+            Featurizer instance for generating features from raw waveform.
+        use_single_scale_clus (bool):
+            Use only one scale for clustering instead of using multiple scales of embeddings for clustering.
+        seq_eval_mode (bool):
+            If True, F1 score will be calculated for each speaker pair during inference mode.
+        window_stride (float):
+            Window stride for acoustic feature. This value is used for calculating the numbers of
+            feature-level frames.
+        pairwise_infer (bool):
+            If True, this Dataset class operates in inference mode. In inference mode, a set of speakers
+            in the input audio is split into multiple pairs of speakers and speaker tuples
+            (e.g. 3 speakers: [(0,1), (1,2), (0,2)]) and then fed into the MSDD to merge the individual results.
+    """
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        emb_dict: Dict,
+        emb_seq: Dict,
+        clus_label_dict: Dict,
+        soft_label_thres: float,
+        use_single_scale_clus: bool,
+        seq_eval_mode: bool,
+        window_stride: float,
+        pairwise_infer: bool,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            emb_dict=emb_dict,
+            emb_seq=emb_seq,
+            clus_label_dict=clus_label_dict,
+            soft_label_thres=soft_label_thres,
+            use_single_scale_clus=use_single_scale_clus,
+            window_stride=window_stride,
+            seq_eval_mode=seq_eval_mode,
+            pairwise_infer=pairwise_infer,
+        )
+
+    def msdd_infer_collate_fn(self, batch):
+        """Collate batch of audio features, feature lengths, target label sequences for inference."""
+        return _msdd_infer_collate_fn(self, batch)
+
+
+class _AudioToSpeechE2ESpkDiarDataset(Dataset):
+    """
+    Dataset class that loads a json file containing paths to audio files,
+    RTTM files and number of speakers. This Dataset class is designed for
+    training or fine-tuning speaker embedding extractor and diarization decoder
+    at the same time.
+
+    Example:
+    {"audio_filepath": "/path/to/audio_0.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_0.rttm}
+    ...
+    {"audio_filepath": "/path/to/audio_n.wav", "num_speakers": 2,
+    "rttm_filepath": "/path/to/diar_label_n.rttm}
+
+    Args:
+        manifest_filepath (str):
+            Path to input manifest json files.
+        multiargs_dict (dict):
+            Dictionary containing the parameters for multiscale segmentation and clustering.
+        soft_label_thres (float):
+            Threshold that determines the label of each segment based on RTTM file information.
+        featurizer:
+            Featurizer instance for generating audio_signal from the raw waveform.
+        window_stride (float):
+            Window stride for acoustic feature. This value is used for calculating the numbers of feature-level frames.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        output_types = {
+            "audio_signal": NeuralType(('B', 'T'), AudioSignal()),
+            "audio_length": NeuralType(('B'), LengthsType()),
+            "targets": NeuralType(('B', 'T', 'C'), ProbsType()),
+            "target_len": NeuralType(('B'), LengthsType()),
+        }
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        soft_label_thres: float,
+        session_len_sec: float,
+        num_spks: int,
+        featurizer,
+        window_stride: float,
+        min_subsegment_duration: float = 0.03,
+        global_rank: int = 0,
+        dtype=torch.float16,
+        round_digits: int = 2,
+        soft_targets: bool = False,
+        subsampling_factor: int = 8,
+        device: str = 'cpu',
+    ):
+        super().__init__()
+        self.collection = EndtoEndDiarizationSpeechLabel(
+            manifests_files=manifest_filepath.split(','),
+            round_digits=round_digits,
+        )
+        self.featurizer = featurizer
+        self.round_digits = round_digits
+        self.feat_per_sec = int(1 / window_stride)
+        self.diar_frame_length = round(subsampling_factor * window_stride, round_digits)
+        self.session_len_sec = session_len_sec
+        self.soft_label_thres = soft_label_thres
+        self.max_spks = num_spks
+        self.min_subsegment_duration = min_subsegment_duration
+        self.dtype = dtype
+        self.use_asr_style_frame_count = True
+        self.soft_targets = soft_targets
+        self.round_digits = 2
+        self.floor_decimal = 10**self.round_digits
+        self.device = device
+
+    def __len__(self):
+        return len(self.collection)
+
+    def get_uniq_id_with_range(self, sample, deci=3):
+        """
+        Generate unique training sample ID from unique file ID, offset and duration. The start-end time added
+        unique ID is required for identifying the sample since multiple short audio samples are generated from a single
+        audio file. The start time and end time of the audio stream uses millisecond units if `deci=3`.
+
+        Args:
+            sample:
+                `DiarizationSpeechLabel` instance from collections.
+
+        Returns:
+            uniq_id (str):
+                Unique sample ID which includes start and end time of the audio stream.
+                Example: abc1001_3122_6458
+        """
+        bare_uniq_id = os.path.splitext(os.path.basename(sample.rttm_file))[0]
+        offset = str(int(round(sample.offset, deci) * pow(10, deci)))
+        endtime = str(int(round(sample.offset + sample.duration, deci) * pow(10, deci)))
+        uniq_id = f"{bare_uniq_id}_{offset}_{endtime}"
+        return uniq_id
+
+    def parse_rttm_for_targets_and_lens(self, rttm_file, offset, duration, target_len):
+        """
+        Generate target tensor variable by extracting groundtruth diarization labels from an RTTM file.
+        This function converts (start, end, speaker_id) format into base-scale (the finest scale) segment level
+        diarization label in a matrix form.
+
+        Example of seg_target:
+            [[0., 1.], [0., 1.], [1., 1.], [1., 0.], [1., 0.], ..., [0., 1.]]
+        """
+        if rttm_file in [None, '']:
+            num_seg = torch.max(target_len)
+            targets = torch.zeros(num_seg, self.max_spks)
+            return targets
+
+        with open(rttm_file, 'r') as f:
+            rttm_lines = f.readlines()
+
+        rttm_timestamps, sess_to_global_spkids = extract_frame_info_from_rttm(offset, duration, rttm_lines)
+
+        fr_level_target = get_frame_targets_from_rttm(
+            rttm_timestamps=rttm_timestamps,
+            offset=offset,
+            duration=duration,
+            round_digits=self.round_digits,
+            feat_per_sec=self.feat_per_sec,
+            max_spks=self.max_spks,
+        )
+
+        soft_target_seg = self.get_soft_targets_seg(feat_level_target=fr_level_target, target_len=target_len)
+        if self.soft_targets:
+            step_target = soft_target_seg
+        else:
+            step_target = (soft_target_seg >= self.soft_label_thres).float()
+        return step_target
+
+    def get_soft_targets_seg(self, feat_level_target, target_len):
+        """
+        Generate the final targets for the actual diarization step.
+        Here, frame level means step level which is also referred to as segments.
+        We follow the original paper and refer to the step level as "frames".
+
+        Args:
+            feat_level_target (torch.tensor):
+                Tensor variable containing hard-labels of speaker activity in each feature-level segment.
+            target_len (torch.tensor):
+                Numbers of ms segments
+
+        Returns:
+            soft_target_seg (torch.tensor):
+                Tensor variable containing soft-labels of speaker activity in each step-level segment.
+        """
+        num_seg = torch.max(target_len)
+        targets = torch.zeros(num_seg, self.max_spks)
+        stride = int(self.feat_per_sec * self.diar_frame_length)
+        for index in range(num_seg):
+            if index == 0:
+                seg_stt_feat = 0
+            else:
+                seg_stt_feat = stride * index - 1 - int(stride / 2)
+            if index == num_seg - 1:
+                seg_end_feat = feat_level_target.shape[0]
+            else:
+                seg_end_feat = stride * index - 1 + int(stride / 2)
+            targets[index] = torch.mean(feat_level_target[seg_stt_feat : seg_end_feat + 1, :], axis=0)
+        return targets
+
+    def get_segment_timestamps(
+        self,
+        duration: float,
+        offset: float = 0,
+        sample_rate: int = 16000,
+    ):
+        """
+        Get start and end time of segments in each scale.
+
+        Args:
+            sample:
+                `DiarizationSpeechLabel` instance from preprocessing.collections
+        Returns:
+            segment_timestamps (torch.tensor):
+                Tensor containing Multiscale segment timestamps.
+            target_len (torch.tensor):
+                Number of segments for each scale. This information is used for reshaping embedding batch
+                during forward propagation.
+        """
+        subsegments = get_subsegments(
+            offset=offset,
+            window=round(self.diar_frame_length * 2, self.round_digits),
+            shift=self.diar_frame_length,
+            duration=duration,
+            min_subsegment_duration=self.min_subsegment_duration,
+            use_asr_style_frame_count=self.use_asr_style_frame_count,
+            sample_rate=sample_rate,
+            feat_per_sec=self.feat_per_sec,
+        )
+        if self.use_asr_style_frame_count:
+            effective_dur = (
+                np.ceil((1 + duration * sample_rate) / int(sample_rate / self.feat_per_sec)).astype(int)
+                / self.feat_per_sec
+            )
+        else:
+            effective_dur = duration
+        ts_tensor = get_subsegments_to_timestamps(
+            subsegments, self.feat_per_sec, decimals=2, max_end_ts=(offset + effective_dur)
+        )
+        target_len = torch.tensor([ts_tensor.shape[0]])
+        return target_len
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+        if sample.offset is None:
+            sample.offset = 0
+        offset = sample.offset
+        if self.session_len_sec < 0:
+            session_len_sec = sample.duration
+        else:
+            session_len_sec = min(sample.duration, self.session_len_sec)
+
+        audio_signal = self.featurizer.process(sample.audio_file, offset=offset, duration=session_len_sec)
+
+        # We should resolve the length mis-match from the round-off errors between these two variables:
+        # `session_len_sec` and `audio_signal.shape[0]`
+        session_len_sec = (
+            np.floor(audio_signal.shape[0] / self.featurizer.sample_rate * self.floor_decimal) / self.floor_decimal
+        )
+        audio_signal = audio_signal[: round(self.featurizer.sample_rate * session_len_sec)]
+        audio_signal_length = torch.tensor(audio_signal.shape[0]).long()
+        target_len = self.get_segment_timestamps(duration=session_len_sec, sample_rate=self.featurizer.sample_rate)
+        targets = self.parse_rttm_for_targets_and_lens(
+            rttm_file=sample.rttm_file, offset=offset, duration=session_len_sec, target_len=target_len
+        )
+        return audio_signal, audio_signal_length, targets, target_len
+
+
+def _eesd_train_collate_fn(self, batch):
+    """
+    Collate a batch of variables needed for training the end-to-end speaker diarization (EESD) model
+    from raw waveforms to diarization labels. The following variables are included in the training/validation batch:
+
+    Args:
+        batch (tuple):
+            A tuple containing the variables for diarization training.
+
+    Returns:
+        audio_signal (torch.Tensor):
+            A tensor containing the raw waveform samples (time series) loaded from the `audio_filepath`
+            in the input manifest file.
+        feature_length (torch.Tensor):
+            A tensor containing the lengths of the raw waveform samples.
+        targets (torch.Tensor):
+            Groundtruth speaker labels for the given input embedding sequence.
+        target_lens (torch.Tensor):
+            A tensor containing the number of segments for each sample in the batch, necessary for
+            reshaping inputs to the EESD model.
+    """
+    packed_batch = list(zip(*batch))
+    audio_signal, feature_length, targets, target_len = packed_batch
+    audio_signal_list, feature_length_list = [], []
+    target_len_list, targets_list = [], []
+
+    max_raw_feat_len = max([x.shape[0] for x in audio_signal])
+    max_target_len = max([x.shape[0] for x in targets])
+    if max([len(feat.shape) for feat in audio_signal]) > 1:
+        max_ch = max([feat.shape[1] for feat in audio_signal])
+    else:
+        max_ch = 1
+    for feat, feat_len, tgt, segment_ct in batch:
+        seq_len = tgt.shape[0]
+        if len(feat.shape) > 1:
+            pad_feat = (0, 0, 0, max_raw_feat_len - feat.shape[0])
+        else:
+            pad_feat = (0, max_raw_feat_len - feat.shape[0])
+        if feat.shape[0] < feat_len:
+            feat_len_pad = feat_len - feat.shape[0]
+            feat = torch.nn.functional.pad(feat, (0, feat_len_pad))
+        pad_tgt = (0, 0, 0, max_target_len - seq_len)
+        padded_feat = torch.nn.functional.pad(feat, pad_feat)
+        padded_tgt = torch.nn.functional.pad(tgt, pad_tgt)
+        if max_ch > 1 and padded_feat.shape[1] < max_ch:
+            feat_ch_pad = max_ch - padded_feat.shape[1]
+            padded_feat = torch.nn.functional.pad(padded_feat, (0, feat_ch_pad))
+        audio_signal_list.append(padded_feat)
+        feature_length_list.append(feat_len.clone().detach())
+        target_len_list.append(segment_ct.clone().detach())
+        targets_list.append(padded_tgt)
+        audio_signal = torch.stack(audio_signal_list)
+    feature_length = torch.stack(feature_length_list)
+    target_lens = torch.stack(target_len_list).squeeze(1)
+    targets = torch.stack(targets_list)
+    return audio_signal, feature_length, targets, target_lens
+
+
+class AudioToSpeechE2ESpkDiarDataset(_AudioToSpeechE2ESpkDiarDataset):
+    """
+    Dataset class for loading a JSON file containing paths to audio files,
+    RTTM (Rich Transcription Time Marked) files, and the number of speakers.
+    This class is designed for training or fine-tuning a speaker embedding
+    extractor and diarization decoder simultaneously.
+
+    The JSON manifest file should have entries in the following format:
+
+    Example:
+    {
+        "audio_filepath": "/path/to/audio_0.wav",
+        "num_speakers": 2,
+        "rttm_filepath": "/path/to/diar_label_0.rttm"
+    }
+    ...
+    {
+        "audio_filepath": "/path/to/audio_n.wav",
+        "num_speakers": 2,
+        "rttm_filepath": "/path/to/diar_label_n.rttm"
+    }
+
+    Args:
+        manifest_filepath (str):
+            Path to the input manifest JSON file containing paths to audio and RTTM files.
+        soft_label_thres (float):
+            Threshold for assigning soft labels to segments based on RTTM file information.
+        session_len_sec (float):
+            Duration of each session (in seconds) for training or fine-tuning.
+        num_spks (int):
+            Number of speakers in the audio files.
+        featurizer:
+            Instance of a featurizer for generating features from the raw waveform.
+        window_stride (float):
+            Window stride (in seconds) for extracting acoustic features, used to calculate
+            the number of feature frames.
+        global_rank (int):
+            Global rank of the current process (used for distributed training).
+        soft_targets (bool):
+            Whether or not to use soft targets during training.
+
+    Methods:
+        eesd_train_collate_fn(batch):
+            Collates a batch of data for end-to-end speaker diarization training.
+    """
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        soft_label_thres: float,
+        session_len_sec: float,
+        num_spks: int,
+        featurizer,
+        window_stride,
+        global_rank: int,
+        soft_targets: bool,
+        device: str,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            soft_label_thres=soft_label_thres,
+            session_len_sec=session_len_sec,
+            num_spks=num_spks,
+            featurizer=featurizer,
+            window_stride=window_stride,
+            global_rank=global_rank,
+            soft_targets=soft_targets,
+            device=device,
+        )
+
+    def eesd_train_collate_fn(self, batch):
+        """Collate a batch of data for end-to-end speaker diarization training."""
+        return _eesd_train_collate_fn(self, batch)

nemo/collections/asr/data/audio_to_diar_label_lhotse.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Dict, Optional, Tuple
+
+import torch.utils.data
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_matrices
+
+from nemo.collections.asr.parts.utils.asr_multispeaker_utils import (
+    get_hidden_length_from_sample_length,
+    speaker_to_target,
+)
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+
+
+class LhotseAudioToSpeechE2ESpkDiarDataset(torch.utils.data.Dataset):
+    """
+    This dataset is a Lhotse version of diarization dataset in audio_to_diar_label.py.
+    Unlike native NeMo datasets, Lhotse dataset defines only the mapping from
+    a CutSet (meta-data) to a mini-batch with PyTorch tensors.
+    Specifically, it performs tokenization, I/O, augmentation, and feature extraction (if any).
+    Managing data, sampling, de-duplication across workers/nodes etc. is all handled
+    by Lhotse samplers instead.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Define the output types of the dataset."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'targets': NeuralType(('B', 'T', 'N'), LabelsType()),
+            'target_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(self, cfg):
+        super().__init__()
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.cfg = cfg
+        self.num_speakers = self.cfg.get('num_speakers', 4)
+        self.num_sample_per_mel_frame = int(
+            self.cfg.get('window_stride', 0.01) * self.cfg.get('sample_rate', 16000)
+        )  # 160 samples for every 1ms by default
+        self.num_mel_frame_per_target_frame = int(self.cfg.get('subsampling_factor', 8))
+        self.spk_tar_all_zero = self.cfg.get('spk_tar_all_zero', False)
+
+    def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
+        audio, audio_lens, cuts = self.load_audio(cuts)
+        speaker_activities = []
+        for cut in cuts:
+            speaker_activity = speaker_to_target(
+                a_cut=cut,
+                num_speakers=self.num_speakers,
+                num_sample_per_mel_frame=self.num_sample_per_mel_frame,
+                num_mel_frame_per_asr_frame=self.num_mel_frame_per_target_frame,
+                spk_tar_all_zero=self.spk_tar_all_zero,
+                boundary_segments=True,
+            )
+            speaker_activities.append(speaker_activity)
+        targets = collate_matrices(speaker_activities).to(audio.dtype)
+        target_lens_list = []
+        for audio_len in audio_lens:
+            target_fr_len = get_hidden_length_from_sample_length(
+                audio_len, self.num_sample_per_mel_frame, self.num_mel_frame_per_target_frame
+            )
+            target_lens_list.append(target_fr_len)
+        target_lens = torch.tensor(target_lens_list)
+
+        return audio, audio_lens, targets, target_lens

nemo/collections/asr/data/audio_to_label.py

@@ -0,0 +1,1420 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 io
+import os
+from typing import Dict, List, Optional, Union
+
+import torch
+import webdataset as wds
+
+from nemo.collections.asr.data.audio_to_text import cache_datastore_manifests, expand_sharded_filepaths
+from nemo.collections.asr.parts.preprocessing.features import WaveformFeaturizer
+from nemo.collections.asr.parts.preprocessing.segment import available_formats as valid_sf_formats
+from nemo.collections.common.parts.preprocessing import collections
+from nemo.core.classes import Dataset, IterableDataset
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType, RegressionValuesType
+from nemo.utils import logging
+from nemo.utils.distributed import webdataset_split_by_workers
+
+# List of valid file formats (prioritized by order of importance)
+VALID_FILE_FORMATS = ';'.join(['wav', 'mp3', 'flac', 'opus'] + [fmt.lower() for fmt in valid_sf_formats.keys()])
+
+
+def repeat_signal(signal: torch.Tensor, sig_len: int, required_length: int) -> torch.Tensor:
+    """repeat signal to make short signal to have required_length
+    Args:
+        signal (Tensor): input signal
+        sig_len (int): length of input signal
+        required_length (int): length of generated signal
+    Returns:
+        signal (Tensor): generated signal of required_length by repeating itself.
+    """
+    sub: torch.Tensor = torch.tensor([])
+    repeat = int(required_length // sig_len)
+    rem = int(required_length % sig_len)
+    sub: torch.Tensor = torch.tensor([])
+    rep_sig: torch.Tensor = torch.cat(repeat * [signal])
+    if rem > 0:
+        sub = signal[-rem:]
+        signal = torch.cat((rep_sig, sub))
+    else:
+        signal = rep_sig
+    return signal
+
+
+def normalize(signal):
+    """normalize signal
+    Args:
+        signal(FloatTensor): signal to be normalized.
+    """
+    signal_minusmean = signal - signal.mean()
+    return signal_minusmean / signal_minusmean.abs().max()
+
+
+def count_occurence(manifest_file_id):
+    """Count number of wav files in Dict manifest_file_id. Use for _TarredAudioToLabelDataset.
+    Args:
+        manifest_file_id (Dict): Dict of files and their corresponding id. {'A-sub0' : 1, ..., 'S-sub10':100}
+    Returns:
+        count (Dict): Dict of wav files {'A' : 2, ..., 'S':10}
+    """
+    count = dict()
+    for i in manifest_file_id:
+        audio_filename = i.split("-sub")[0]
+        count[audio_filename] = count.get(audio_filename, 0) + 1
+    return count
+
+
+def _speech_collate_fn(batch, pad_id):
+    """collate batch of audio sig, audio len, tokens, tokens len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+               LongTensor):  A tuple of tuples of signal, signal lengths,
+               encoded tokens, and encoded tokens length.  This collate func
+               assumes the signals are 1d torch tensors (i.e. mono audio).
+    """
+    _, audio_lengths, _, tokens_lengths = zip(*batch)
+    max_audio_len = 0
+    has_audio = audio_lengths[0] is not None
+    if has_audio:
+        max_audio_len = max(audio_lengths).item()
+    max_tokens_len = max(tokens_lengths).item()
+
+    audio_signal, tokens = [], []
+    for sig, sig_len, tokens_i, tokens_i_len in batch:
+        if has_audio:
+            sig_len = sig_len.item()
+            if sig_len < max_audio_len:
+                pad = (0, max_audio_len - sig_len)
+                sig = torch.nn.functional.pad(sig, pad)
+            audio_signal.append(sig)
+        tokens_i_len = tokens_i_len.item()
+        if tokens_i_len < max_tokens_len:
+            pad = (0, max_tokens_len - tokens_i_len)
+            tokens_i = torch.nn.functional.pad(tokens_i, pad, value=pad_id)
+        tokens.append(tokens_i)
+
+    if has_audio:
+        audio_signal = torch.stack(audio_signal)
+        audio_lengths = torch.stack(audio_lengths)
+    else:
+        audio_signal, audio_lengths = None, None
+    tokens = torch.stack(tokens)
+    tokens_lengths = torch.stack(tokens_lengths)
+
+    return audio_signal, audio_lengths, tokens, tokens_lengths
+
+
+def _fixed_seq_collate_fn(self, batch):
+    """collate batch of audio sig, audio len, tokens, tokens len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+            LongTensor):  A tuple of tuples of signal, signal lengths,
+            encoded tokens, and encoded tokens length.  This collate func
+            assumes the signals are 1d torch tensors (i.e. mono audio).
+    """
+    _, audio_lengths, _, tokens_lengths = zip(*batch)
+
+    has_audio = audio_lengths[0] is not None
+    fixed_length = int(max(audio_lengths))
+
+    audio_signal, tokens, new_audio_lengths = [], [], []
+    for sig, sig_len, tokens_i, _ in batch:
+        if has_audio:
+            sig_len = sig_len.item()
+            chunck_len = sig_len - fixed_length
+
+            if chunck_len < 0:
+                repeat = fixed_length // sig_len
+                rem = fixed_length % sig_len
+                sub = sig[-rem:] if rem > 0 else torch.tensor([])
+                rep_sig = torch.cat(repeat * [sig])
+                sig = torch.cat((rep_sig, sub))
+            new_audio_lengths.append(torch.tensor(fixed_length))
+
+            audio_signal.append(sig)
+
+        tokens.append(tokens_i)
+
+    if has_audio:
+        audio_signal = torch.stack(audio_signal)
+        audio_lengths = torch.stack(new_audio_lengths)
+    else:
+        audio_signal, audio_lengths = None, None
+    tokens = torch.stack(tokens)
+    tokens_lengths = torch.stack(tokens_lengths)
+
+    return audio_signal, audio_lengths, tokens, tokens_lengths
+
+
+def _vad_frame_seq_collate_fn(self, batch):
+    """collate batch of audio sig, audio len, tokens, tokens len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+            LongTensor):  A tuple of tuples of signal, signal lengths,
+            encoded tokens, and encoded tokens length.  This collate func
+            assumes the signals are 1d torch tensors (i.e. mono audio).
+            batch size equals to 1.
+    """
+    slice_length = int(self.featurizer.sample_rate * self.window_length_in_sec)
+    _, audio_lengths, _, tokens_lengths = zip(*batch)
+    slice_length = int(min(slice_length, max(audio_lengths)))
+    shift = int(self.featurizer.sample_rate * self.shift_length_in_sec)
+    has_audio = audio_lengths[0] is not None
+
+    audio_signal, num_slices, tokens, audio_lengths = [], [], [], []
+
+    append_len_start = slice_length // 2
+    append_len_end = slice_length - slice_length // 2
+    for sig, sig_len, tokens_i, _ in batch:
+        if self.normalize_audio:
+            sig = normalize(sig)
+        start = torch.zeros(append_len_start)
+        end = torch.zeros(append_len_end)
+        sig = torch.cat((start, sig, end))
+        sig_len += slice_length
+
+        if has_audio:
+            slices = torch.div(sig_len - slice_length, shift, rounding_mode='trunc')
+            for slice_id in range(slices):
+                start_idx = slice_id * shift
+                end_idx = start_idx + slice_length
+                signal = sig[start_idx:end_idx]
+                audio_signal.append(signal)
+
+            num_slices.append(slices)
+            tokens.extend([tokens_i] * slices)
+            audio_lengths.extend([slice_length] * slices)
+
+    if has_audio:
+        audio_signal = torch.stack(audio_signal)
+        audio_lengths = torch.tensor(audio_lengths)
+    else:
+        audio_signal, audio_lengths = None, None
+
+    tokens = torch.stack(tokens)
+    tokens_lengths = torch.tensor(num_slices)
+    return audio_signal, audio_lengths, tokens, tokens_lengths
+
+
+class _AudioLabelDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio files,
+    labels, and durations and offsets(in seconds). Each new line is a
+    different sample. Example below:
+    and their target labels. JSON files should be of the following format::
+        {"audio_filepath": "/path/to/audio_wav_0.wav", "duration": time_in_sec_0, "label": \
+target_label_0, "offset": offset_in_sec_0}
+        ...
+        {"audio_filepath": "/path/to/audio_wav_n.wav", "duration": time_in_sec_n, "label": \
+target_label_n, "offset": offset_in_sec_n}
+    Args:
+        manifest_filepath (Union[str, List[str]]): Dataset parameter. Path to JSON containing data.
+        labels (list): Dataset parameter. List of target classes that can be output by the speaker recognition model.
+        featurizer
+        min_duration (float): Dataset parameter. All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim (bool): Whether to use trim silence from beginning and end of audio signal using librosa.effects.trim().
+            Defaults to False.
+        channel selector (Union[str, int, List[int]]): string denoting the downmix mode, an integer denoting the channel to be selected, or an iterable
+            of integers denoting a subset of channels. Channel selector is using zero-based indexing.
+            If set to `None`, the original signal will be used.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+
+        output_types = {
+            'audio_signal': NeuralType(
+                ('B', 'T'),
+                (
+                    AudioSignal(freq=self._sample_rate)
+                    if self is not None and hasattr(self, '_sample_rate')
+                    else AudioSignal()
+                ),
+            ),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        if self.is_regression_task:
+            output_types.update(
+                {
+                    'targets': NeuralType(tuple('B'), RegressionValuesType()),
+                    'targets_length': NeuralType(tuple('B'), LengthsType()),
+                }
+            )
+        else:
+
+            output_types.update(
+                {
+                    'label': NeuralType(tuple('B'), LabelsType()),
+                    'label_length': NeuralType(tuple('B'), LengthsType()),
+                }
+            )
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: Union[str, List[str]],
+        labels: List[str],
+        featurizer,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        channel_selector: Union[str, int, List[int]] = None,
+        is_regression_task: bool = False,
+        cal_labels_occurrence: Optional[bool] = False,
+    ):
+        super().__init__()
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(',')
+        cache_datastore_manifests(manifest_filepaths=manifest_filepath, cache_audio=True)
+        self.collection = collections.ASRSpeechLabel(
+            manifests_files=manifest_filepath,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            is_regression_task=is_regression_task,
+            cal_labels_occurrence=cal_labels_occurrence,
+        )
+
+        self.featurizer = featurizer
+        self.trim = trim
+        self.channel_selector = channel_selector
+        self.is_regression_task = is_regression_task
+
+        if not is_regression_task:
+            self.labels = labels if labels else self.collection.uniq_labels
+            self.num_classes = len(self.labels) if self.labels is not None else 1
+            self.label2id, self.id2label = {}, {}
+            self.id2occurrence, self.labels_occurrence = {}, []
+
+            for label_id, label in enumerate(self.labels):
+                self.label2id[label] = label_id
+                self.id2label[label_id] = label
+                if cal_labels_occurrence:
+                    self.id2occurrence[label_id] = self.collection.labels_occurrence[label]
+
+            if cal_labels_occurrence:
+                self.labels_occurrence = [self.id2occurrence[k] for k in sorted(self.id2occurrence)]
+
+            for idx in range(len(self.labels[:5])):
+                logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+
+        else:
+            self.labels = []
+            self.num_classes = 1
+
+    def __len__(self):
+        return len(self.collection)
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        offset = sample.offset
+
+        if offset is None:
+            offset = 0
+
+        features = self.featurizer.process(
+            sample.audio_file,
+            offset=offset,
+            duration=sample.duration,
+            trim=self.trim,
+            channel_selector=self.channel_selector,
+        )
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        if not self.is_regression_task:
+            t = torch.tensor(self.label2id[sample.label]).long()
+        else:
+            t = torch.tensor(sample.label).float()
+
+        tl = torch.tensor(1).long()  # For compatibility with collate_fn used later
+
+        return f, fl, t, tl
+
+
+# Ported from https://github.com/NVIDIA/OpenSeq2Seq/blob/master/open_seq2seq/data/speech2text/speech_commands.py
+class AudioToClassificationLabelDataset(_AudioLabelDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio
+    files, command class, and durations (in seconds). Each new line is a
+    different sample. Example below:
+    {"audio_filepath": "/path/to/audio_wav_0.wav", "duration": time_in_sec_0, "label": \
+        target_label_0, "offset": offset_in_sec_0}
+    ...
+    {"audio_filepath": "/path/to/audio_wav_n.wav", "duration": time_in_sec_n, "label": \
+        target_label_n, "offset": offset_in_sec_n}
+    Args:
+        manifest_filepath (Union[str, List[str]]): Path to manifest json as described above. Can
+            be comma-separated paths.
+        labels (Optional[list]): String containing all the possible labels to map to
+            if None then automatically picks from ASRSpeechLabel collection.
+        featurizer: Initialized featurizer class that converts paths of
+            audio to feature tensors
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include
+            in dataset
+        trim: Boolean flag whether to trim the audio
+    """
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=0)
+
+
+class AudioToSpeechLabelDataset(_AudioLabelDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio
+    files, command class, and durations (in seconds). Each new line is a
+    different sample. Example below:
+    {"audio_filepath": "/path/to/audio_wav_0.wav", "duration": time_in_sec_0, "label": \
+        target_label_0, "offset": offset_in_sec_0}
+    ...
+    {"audio_filepath": "/path/to/audio_wav_n.wav", "duration": time_in_sec_n, "label": \
+        target_label_n, "offset": offset_in_sec_n}
+    Args:
+        manifest_filepath (Union[str, List[str]]): Path to manifest json as described above. Can
+            be comma-separated paths.
+        labels (Optional[list]): String containing all the possible labels to map to
+            if None then automatically picks from ASRSpeechLabel collection.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim (bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        channel selector (Union[str, int, List[int]]): string denoting the downmix mode, an integer denoting the channel to be selected, or an iterable
+            of integers denoting a subset of channels. Channel selector is using zero-based indexing.
+            If set to `None`, the original signal will be used.
+        window_length_in_sec (float): length of window/slice (in seconds)
+            Use this for speaker recognition and VAD tasks.
+        shift_length_in_sec (float): amount of shift of window for generating the frame for VAD task in a batch
+            Use this for VAD task during inference.
+        normalize_audio (bool): Whether to normalize audio signal.
+            Defaults to False.
+        is_regression_task (bool): Whether the dataset is for a regression task instead of classification.
+            Defaults to False.
+        cal_labels_occurrence (bool): Whether to calculate occurrence of labels
+            Defaults to False.
+    """
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: Union[str, List[str]],
+        labels: List[str],
+        featurizer,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        channel_selector: Optional[Union[str, int, List[int]]] = None,
+        window_length_in_sec: Optional[float] = 8,
+        shift_length_in_sec: Optional[float] = 1,
+        normalize_audio: bool = False,
+        is_regression_task: bool = False,
+        cal_labels_occurrence: Optional[bool] = False,
+    ):
+        self.window_length_in_sec = window_length_in_sec
+        self.shift_length_in_sec = shift_length_in_sec
+        self.normalize_audio = normalize_audio
+
+        logging.debug("Window/slice length considered for collate func is {}".format(self.window_length_in_sec))
+        logging.debug("Shift length considered for collate func is {}".format(self.shift_length_in_sec))
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            labels=labels,
+            featurizer=featurizer,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            trim=trim,
+            channel_selector=channel_selector,
+            is_regression_task=is_regression_task,
+            cal_labels_occurrence=cal_labels_occurrence,
+        )
+
+    def fixed_seq_collate_fn(self, batch):
+        return _fixed_seq_collate_fn(self, batch)
+
+    def vad_frame_seq_collate_fn(self, batch):
+        return _vad_frame_seq_collate_fn(self, batch)
+
+
+class _TarredAudioLabelDataset(IterableDataset):
+    """
+    A similar Dataset to the AudioLabelDataSet, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToSpeechLabelDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the label and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    Note: For brace expansion in (1), there may be cases where `{x..y}` syntax cannot be used due to shell interference.
+    This occurs most commonly inside SLURM scripts. Therefore we provide a few equivalent replacements.
+    Supported opening braces - { <=> (, [, < and the special tag _OP_.
+    Supported closing braces - } <=> ), ], > and the special tag _CL_.
+    For SLURM based tasks, we suggest the use of the special tags for ease of use.
+
+    See the documentation for more information about accepted data and input formats.
+
+    If using multiple processes the number of shards should be divisible by the number of workers to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioLabelDataSet; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        labels (list): Dataset parameter.
+            List of target classes that can be output by the speaker recognition model.
+        featurizer
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim(bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        window_length_in_sec (float): length of slice/window (in seconds) # Pass this only for speaker recognition and VAD task
+        shift_length_in_sec (float): amount of shift of window for generating the frame for VAD task. in a batch # Pass this only for VAD task during inference.
+        normalize_audio (bool): Whether to normalize audio signal. Defaults to False.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on the value of `shuffle_n`.
+
+                .. warning::
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        is_regression_task (bool): Whether it is a regression task. Defualts to False.
+    """
+
+    def __init__(
+        self,
+        *,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: Union[str, List[str]],
+        labels: List[str],
+        featurizer,
+        shuffle_n: int = 0,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        shard_strategy: str = "scatter",
+        global_rank: int = 0,
+        world_size: int = 0,
+        is_regression_task: bool = False,
+    ):
+        cache_datastore_manifests(manifest_filepaths=manifest_filepath)
+        self.collection = collections.ASRSpeechLabel(
+            manifests_files=manifest_filepath,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            index_by_file_id=True,  # Must set this so the manifest lines can be indexed by file ID
+        )
+
+        self.file_occurence = count_occurence(self.collection.mapping)
+
+        self.featurizer = featurizer
+        self.trim = trim
+
+        self.labels = labels if labels else self.collection.uniq_labels
+        self.num_classes = len(self.labels)
+
+        self.label2id, self.id2label = {}, {}
+        for label_id, label in enumerate(self.labels):
+            self.label2id[label] = label_id
+            self.id2label[label_id] = label
+
+        for idx in range(len(self.labels[:5])):
+            logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+
+        audio_tar_filepaths = expand_sharded_filepaths(
+            sharded_filepaths=audio_tar_filepaths,
+            shard_strategy=shard_strategy,
+            world_size=world_size,
+            global_rank=global_rank,
+        )
+        # Put together WebDataset
+        self._dataset = wds.DataPipeline(
+            wds.SimpleShardList(urls=audio_tar_filepaths),
+            webdataset_split_by_workers,
+            wds.shuffle(shuffle_n),
+            wds.tarfile_to_samples(),
+            wds.rename(audio=VALID_FILE_FORMATS, key='__key__'),
+            wds.to_tuple('audio', 'key'),
+            self._filter,
+            wds.map(self._build_sample),
+        )
+
+    def _filter(self, iterator):
+        """This function is used to remove samples that have been filtered out by ASRSpeechLabel already.
+        Otherwise, we would get a KeyError as _build_sample attempts to find the manifest entry for a sample
+        that was filtered out (e.g. for duration).
+        Note that if using multi-GPU training, filtering may lead to an imbalance in samples in each shard,
+        which may make your code hang as one process will finish before the other.
+        """
+
+        class TarredAudioFilter:
+            def __init__(self, collection, file_occurence):
+                self.iterator = iterator
+                self.collection = collection
+                self.file_occurence = file_occurence
+                self._iterable = self._internal_generator()
+
+            def __iter__(self):
+                self._iterable = self._internal_generator()
+                return self
+
+            def __next__(self):
+                try:
+                    values = next(self._iterable)
+                except StopIteration:
+                    # reset generator
+                    self._iterable = self._internal_generator()
+                    values = next(self._iterable)
+
+                return values
+
+            def _internal_generator(self):
+                """
+                WebDataset requires an Iterator, but we require an iterable that yields 1-or-more
+                values per value inside self.iterator.
+
+                Therefore wrap the iterator with a generator function that will yield 1-or-more
+                values per sample in the iterator.
+                """
+                for _, tup in enumerate(self.iterator):
+                    audio_bytes, audio_filename = tup
+
+                    file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+                    if audio_filename in self.file_occurence:
+                        for j in range(0, self.file_occurence[file_id]):
+                            if j == 0:
+                                audio_filename = file_id
+                            else:
+                                audio_filename = file_id + "-sub" + str(j)
+                            yield audio_bytes, audio_filename
+
+        return TarredAudioFilter(self.collection, self.file_occurence)
+
+    def _build_sample(self, tup):
+        """Builds the training sample by combining the data from the WebDataset with the manifest info."""
+        audio_bytes, audio_filename = tup
+        # Grab manifest entry from self.collection
+        file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+
+        manifest_idx = self.collection.mapping[file_id]
+        manifest_entry = self.collection[manifest_idx]
+
+        offset = manifest_entry.offset
+        if offset is None:
+            offset = 0
+
+        # Convert audio bytes to IO stream for processing (for SoundFile to read)
+        audio_filestream = io.BytesIO(audio_bytes)
+        features = self.featurizer.process(
+            audio_filestream,
+            offset=offset,
+            duration=manifest_entry.duration,
+            trim=self.trim,
+        )
+
+        audio_filestream.close()
+
+        # Audio features
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        t = self.label2id[manifest_entry.label]
+        tl = 1  # For compatibility with collate_fn used later
+
+        return f, fl, torch.tensor(t).long(), torch.tensor(tl).long()
+
+    def __iter__(self):
+        return self._dataset.__iter__()
+
+    def __len__(self):
+        return len(self.collection)
+
+
+class TarredAudioToClassificationLabelDataset(_TarredAudioLabelDataset):
+    """
+    A similar Dataset to the AudioToClassificationLabelDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToClassificationLabelDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple processes the number of shards should be divisible by the number of workers to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToBPEDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        labels (list): Dataset parameter.
+            List of target classes that can be output by the speaker recognition model.
+        featurizer
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim(bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        is_regression_task (bool): Whether it is a regression task. Defualts to False.
+    """
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=0)
+
+
+class TarredAudioToSpeechLabelDataset(_TarredAudioLabelDataset):
+    """
+    A similar Dataset to the AudioToSpeechLabelDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToSpeechLabelDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple processes the number of shards should be divisible by the number of workers to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToBPEDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        labels (list): Dataset parameter.
+            List of target classes that can be output by the speaker recognition model.
+        featurizer
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim(bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        window_length_in_sec (float): time length of window/slice (in seconds) # Pass this only for speaker recognition and VAD task
+        shift_length_in_sec (float): amount of shift of window for generating the frame for VAD task. in a batch # Pass this only for VAD task during inference.
+        normalize_audio (bool): Whether to normalize audio signal. Defaults to False.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        *,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: Union[str, List[str]],
+        labels: List[str],
+        featurizer,
+        shuffle_n: int = 0,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        window_length_in_sec: Optional[float] = 8,
+        shift_length_in_sec: Optional[float] = 1,
+        normalize_audio: bool = False,
+        shard_strategy: str = "scatter",
+        global_rank: int = 0,
+        world_size: int = 0,
+    ):
+        logging.info("Window/slice length considered for collate func is {}".format(window_length_in_sec))
+        logging.info("Shift length considered for collate func is {}".format(shift_length_in_sec))
+        self.window_length_in_sec = window_length_in_sec
+        self.shift_length_in_sec = shift_length_in_sec
+        self.normalize_audio = normalize_audio
+
+        super().__init__(
+            audio_tar_filepaths=audio_tar_filepaths,
+            manifest_filepath=manifest_filepath,
+            labels=labels,
+            featurizer=featurizer,
+            shuffle_n=shuffle_n,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            trim=trim,
+            shard_strategy=shard_strategy,
+            global_rank=global_rank,
+            world_size=world_size,
+        )
+
+    def fixed_seq_collate_fn(self, batch):
+        return _fixed_seq_collate_fn(self, batch)
+
+    def sliced_seq_collate_fn(self, batch):
+        raise NotImplementedError
+
+    def vad_frame_seq_collate_fn(self, batch):
+        return _vad_frame_seq_collate_fn(self, batch)
+
+
+class AudioToMultiLabelDataset(Dataset):
+    """
+    Dataset that loads a json file containing paths to audio files, durations (in seconds), and a sequence of labels.
+    Each new line is a different sample. Example below:
+    {"audio_filepath": "/path/to/audio_wav_0.wav", "duration": time_in_sec_0, "label": \
+        "0 1 1 0 1", "offset": offset_in_sec_0}
+    ...
+    {"audio_filepath": "/path/to/audio_wav_n.wav", "duration": time_in_sec_n, "label": \
+        "0 1 0 0 1", "offset": offset_in_sec_n}
+    Args:
+        manifest_filepath (Union[str, List[str]]): Path to manifest json as described above. Can
+            be comma-separated paths.
+        labels (Optional[list]): String containing all the possible labels to map to
+            if None then automatically picks from ASRSpeechLabel collection.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim_silence (bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        channel selector (Union[str, int, List[int]]): string denoting the downmix mode, an integer denoting the channel to be selected, or an iterable
+            of integers denoting a subset of channels. Channel selector is using zero-based indexing.
+            If set to `None`, the original signal will be used.
+        window_length_in_sec (float): length of window/slice (in seconds)
+            Use this for speaker recognition and VAD tasks.
+        shift_length_in_sec (float): amount of shift of window for generating the frame for VAD task in a batch
+            Use this for VAD task during inference.
+        normalize_audio (bool): Whether to normalize audio signal.
+            Defaults to False.
+        is_regression_task (bool): Whether the dataset is for a regression task instead of classification.
+            Defaults to False.
+        cal_labels_occurrence (bool): Whether to calculate occurrence of labels
+            Defaults to False.
+        delimiter (Optional[str]): Delimiter to use when splitting the label string, default to None.
+        normalize_audio_db (Optional[float]):  normalize audio signal to a target db, default to None.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+
+        output_types = {
+            'audio_signal': NeuralType(
+                ('B', 'T'),
+                (
+                    AudioSignal(freq=self._sample_rate)
+                    if self is not None and hasattr(self, '_sample_rate')
+                    else AudioSignal()
+                ),
+            ),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        if self.is_regression_task:
+            output_types.update(
+                {
+                    'targets': NeuralType(tuple('B, T'), RegressionValuesType()),
+                    'targets_length': NeuralType(tuple('B'), LengthsType()),
+                }
+            )
+        else:
+            output_types.update(
+                {
+                    'label': NeuralType(('B', 'T'), LabelsType()),
+                    'label_length': NeuralType(tuple('B'), LengthsType()),
+                }
+            )
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: Union[str, List[str]],
+        sample_rate: int,
+        labels: Optional[List[str]] = None,
+        int_values: bool = False,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim_silence: bool = False,
+        channel_selector: Optional[Union[str, int, List[int]]] = None,
+        is_regression_task: bool = False,
+        cal_labels_occurrence: Optional[bool] = False,
+        delimiter: Optional[str] = None,
+        normalize_audio_db: Optional[float] = None,
+    ):
+        super().__init__()
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(',')
+
+        self.delimiter = delimiter
+        self.normalize_audio_db = normalize_audio_db
+
+        self.collection = collections.ASRSpeechLabel(
+            manifests_files=manifest_filepath,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            is_regression_task=is_regression_task,
+            cal_labels_occurrence=cal_labels_occurrence,
+            delimiter=delimiter,
+        )
+
+        self.featurizer = WaveformFeaturizer(sample_rate=sample_rate, int_values=int_values, augmentor=augmentor)
+        self.trim = trim_silence
+        self.channel_selector = channel_selector
+        self.is_regression_task = is_regression_task
+        self.id2occurrence = {}
+        self.labels_occurrence = None
+
+        if not is_regression_task:
+            self.labels = labels if labels else self._get_label_set()
+            self.num_classes = len(self.labels) if self.labels is not None else 1
+            self.label2id, self.id2label = {}, {}
+            for label_id, label in enumerate(self.labels):
+                self.label2id[label] = label_id
+                self.id2label[label_id] = label
+                if cal_labels_occurrence:
+                    self.id2occurrence[label_id] = self.collection.labels_occurrence[label]
+                    self.labels_occurrence.append(self.id2occurrence[label_id])
+
+            for idx in range(len(self.labels[:5])):
+                logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+        else:
+            self.labels = []
+            self.num_classes = 1
+
+    def _get_label_set(self):
+        labels = []
+        for sample in self.collection:
+            label_str = sample.label
+            if label_str:
+                label_str_list = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+                labels.extend(label_str_list)
+        return sorted(set(labels))
+
+    def _label_str_to_tensor(self, label_str: str):
+        labels = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+
+        if self.is_regression_task:
+            labels = [float(s) for s in labels]
+            labels = torch.tensor(labels).float()
+        else:
+            labels = [self.label2id[s] for s in labels]
+            labels = torch.tensor(labels).long()
+        return labels
+
+    def __len__(self):
+        return len(self.collection)
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        offset = sample.offset
+
+        if offset is None:
+            offset = 0
+
+        features = self.featurizer.process(
+            sample.audio_file,
+            offset=offset,
+            duration=sample.duration,
+            trim=self.trim,
+            channel_selector=self.channel_selector,
+            normalize_db=self.normalize_audio_db,
+        )
+
+        f, fl = features, torch.tensor(features.size(0)).long()
+
+        t = self._label_str_to_tensor(sample.label)
+
+        tl = torch.tensor(t.size(0)).long()
+
+        return f, fl, t, tl
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=0)
+
+
+class TarredAudioToMultiLabelDataset(IterableDataset):
+    """
+    A similar Dataset to the AudioToMultiLabelDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToSpeechLabelDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple processes the number of shards should be divisible by the number of workers to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToBPEDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        labels (list): Dataset parameter.
+            List of target classes that can be output by the speaker recognition model.
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim(bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        window_length_in_sec (float): time length of window/slice (in seconds) # Pass this only for speaker recognition and VAD task
+        shift_length_in_sec (float): amount of shift of window for generating the frame for VAD task. in a batch # Pass this only for VAD task during inference.
+        normalize_audio (bool): Whether to normalize audio signal. Defaults to False.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        delimiter (Optional[str]): Delimiter to use when splitting the label string, default to None.
+        normalize_audio_db (Optional[float]):  normalize audio signal to a target db, default to None.
+    """
+
+    def __init__(
+        self,
+        *,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: Union[str, List[str]],
+        sample_rate: int,
+        labels: Optional[List[str]] = None,
+        shuffle_n: int = 0,
+        int_values: bool = False,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        min_duration: Optional[float] = 0.1,
+        max_duration: Optional[float] = None,
+        trim_silence: bool = False,
+        is_regression_task: bool = False,
+        shard_strategy: str = "scatter",
+        global_rank: int = 0,
+        world_size: int = 0,
+        delimiter: Optional[str] = None,
+        normalize_audio_db: Optional[float] = None,
+    ):
+        super().__init__()
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(',')
+
+        self.trim = trim_silence
+        self.is_regression_task = is_regression_task
+        self.delimiter = delimiter
+        self.normalize_audio_db = normalize_audio_db
+
+        self.collection = collections.ASRSpeechLabel(
+            manifests_files=manifest_filepath,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            is_regression_task=is_regression_task,
+            index_by_file_id=True,
+        )
+        self.file_occurence = count_occurence(self.collection.mapping)
+
+        self.featurizer = WaveformFeaturizer(sample_rate=sample_rate, int_values=int_values, augmentor=augmentor)
+
+        if not is_regression_task:
+            self.labels = labels if labels else self._get_label_set()
+            self.num_classes = len(self.labels) if self.labels is not None else 1
+            self.label2id, self.id2label = {}, {}
+            for label_id, label in enumerate(self.labels):
+                self.label2id[label] = label_id
+                self.id2label[label_id] = label
+            for idx in range(len(self.labels[:5])):
+                logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+        else:
+            self.labels = []
+            self.num_classes = 1
+
+        audio_tar_filepaths = expand_sharded_filepaths(
+            sharded_filepaths=audio_tar_filepaths,
+            shard_strategy=shard_strategy,
+            world_size=world_size,
+            global_rank=global_rank,
+        )
+        # Put together WebDataset
+        self._dataset = wds.DataPipeline(
+            wds.SimpleShardList(urls=audio_tar_filepaths),
+            webdataset_split_by_workers,
+            wds.shuffle(shuffle_n),
+            wds.tarfile_to_samples(),
+            wds.rename(audio=VALID_FILE_FORMATS, key='__key__'),
+            wds.to_tuple('audio', 'key'),
+            self._filter,
+            wds.map(self._build_sample),
+        )
+
+    def _get_label_set(self):
+        labels = []
+        for sample in self.collection:
+            label_str = sample.label
+            if label_str:
+                label_str_list = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+                labels.extend(label_str_list)
+        return sorted(set(labels))
+
+    def _label_str_to_tensor(self, label_str: str):
+        labels = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+
+        if self.is_regression_task:
+            labels = [float(s) for s in labels]
+            labels = torch.tensor(labels).float()
+        else:
+            labels = [self.label2id[s] for s in labels]
+            labels = torch.tensor(labels).long()
+        return labels
+
+    def _filter(self, iterator):
+        """This function is used to remove samples that have been filtered out by ASRSpeechLabel already.
+        Otherwise, we would get a KeyError as _build_sample attempts to find the manifest entry for a sample
+        that was filtered out (e.g. for duration).
+        Note that if using multi-GPU training, filtering may lead to an imbalance in samples in each shard,
+        which may make your code hang as one process will finish before the other.
+        """
+
+        class TarredAudioFilter:
+            def __init__(self, collection, file_occurence):
+                self.iterator = iterator
+                self.collection = collection
+                self.file_occurence = file_occurence
+                self._iterable = self._internal_generator()
+
+            def __iter__(self):
+                self._iterable = self._internal_generator()
+                return self
+
+            def __next__(self):
+                try:
+                    values = next(self._iterable)
+                except StopIteration:
+                    # reset generator
+                    self._iterable = self._internal_generator()
+                    values = next(self._iterable)
+
+                return values
+
+            def _internal_generator(self):
+                """
+                WebDataset requires an Iterator, but we require an iterable that yields 1-or-more
+                values per value inside self.iterator.
+
+                Therefore wrap the iterator with a generator function that will yield 1-or-more
+                values per sample in the iterator.
+                """
+                for _, tup in enumerate(self.iterator):
+                    audio_bytes, audio_filename = tup
+
+                    file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+                    if audio_filename in self.file_occurence:
+                        for j in range(0, self.file_occurence[file_id]):
+                            if j == 0:
+                                audio_filename = file_id
+                            else:
+                                audio_filename = file_id + "-sub" + str(j)
+                            yield audio_bytes, audio_filename
+
+        return TarredAudioFilter(self.collection, self.file_occurence)
+
+    def _build_sample(self, tup):
+        """Builds the training sample by combining the data from the WebDataset with the manifest info."""
+        audio_bytes, audio_filename = tup
+        # Grab manifest entry from self.collection
+        file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+
+        manifest_idx = self.collection.mapping[file_id]
+        manifest_entry = self.collection[manifest_idx]
+
+        offset = manifest_entry.offset
+        if offset is None:
+            offset = 0
+
+        # Convert audio bytes to IO stream for processing (for SoundFile to read)
+        audio_filestream = io.BytesIO(audio_bytes)
+        features = self.featurizer.process(
+            audio_filestream,
+            offset=offset,
+            duration=manifest_entry.duration,
+            trim=self.trim,
+            normalize_db=self.normalize_audio_db,
+        )
+
+        audio_filestream.close()
+
+        # Audio features
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        t = self._label_str_to_tensor(manifest_entry.label)
+
+        tl = torch.tensor(t.size(0)).long()
+
+        return f, fl, t, tl
+
+    def __iter__(self):
+        return self._dataset.__iter__()
+
+    def __len__(self):
+        return len(self.collection)
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=0)
+
+
+class AudioPairToLabelDataset(AudioToSpeechLabelDataset):
+    """
+    Dataset class for audio pairs classification tasks, such as calculating EER for speaker verification.
+    The input manifest file should contain pairs of audio files and a label. It's format is almost the same as
+    `AudioToSpeechLabelDataset` except that the `audio_filepath` field should be a list of two audio file paths
+    instead of one, and that `offset` and `duration` are not used as the dataset class will load the whole audio.
+
+    Example of a line in the manifest file:
+    {
+        "audio_filepath": ["/path/to/audio_wav_0.wav", "/path/to/audio_wav_1.wav"],
+        "duration": null,  # not used, will load the whole audio
+        "offset": 0.0,  # not used, will load the whole audio
+        "label": "0"  # label for the pair, can be a string or an integer
+    }
+
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+
+        output_types = {
+            'audio_signal': NeuralType(
+                ('B', 'T'),
+                (
+                    AudioSignal(freq=self._sample_rate)
+                    if self is not None and hasattr(self, '_sample_rate')
+                    else AudioSignal()
+                ),
+            ),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'audio_signal_2': NeuralType(
+                ('B', 'T'),
+                (
+                    AudioSignal(freq=self._sample_rate)
+                    if self is not None and hasattr(self, '_sample_rate')
+                    else AudioSignal()
+                ),
+            ),
+            'a_sig_length_2': NeuralType(tuple('B'), LengthsType()),
+            'label': NeuralType(tuple('B'), LabelsType()),
+            'label_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str | List[str],
+        labels: List[str],
+        featurizer,
+        min_duration: float | None = 0.1,
+        max_duration: float | None = None,
+        trim: bool = False,
+        window_length_in_sec: float | None = 8,
+        shift_length_in_sec: float | None = 1,
+        normalize_audio: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            labels=labels,
+            featurizer=featurizer,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            trim=trim,
+            window_length_in_sec=window_length_in_sec,
+            shift_length_in_sec=shift_length_in_sec,
+            normalize_audio=normalize_audio,
+            is_regression_task=False,
+            cal_labels_occurrence=False,
+        )
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        audio_pair = sample.audio_file
+
+        features = self.featurizer.process(audio_pair[0], offset=0, duration=None, trim=self.trim)
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        features2 = self.featurizer.process(audio_pair[1], offset=0, duration=None, trim=self.trim)
+        f2, fl2 = features2, torch.tensor(features2.shape[0]).long()
+
+        t = torch.tensor(self.label2id[sample.label]).long()
+        tl = torch.tensor(1).long()  # For compatibility with collate_fn used later
+
+        return f, fl, f2, fl2, t, tl
+
+    def fixed_seq_collate_fn(self, batch):
+        audio1, audio_len1, audio2, audio_len2, label, label_len = zip(*batch)
+
+        batch1 = list(zip(audio1, audio_len1, label, label_len))
+        a_sig1, a_sig_len1, pair_label, pair_label_len = _fixed_seq_collate_fn(self, batch1)
+        batch2 = list(zip(audio2, audio_len2, label, label_len))
+        a_sig2, a_sig_len2, _, _ = _fixed_seq_collate_fn(self, batch2)
+        return a_sig1, a_sig_len1, a_sig2, a_sig_len2, pair_label, pair_label_len

nemo/collections/asr/data/audio_to_label_dataset.py

@@ -0,0 +1,304 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 copy
+
+from omegaconf import DictConfig
+
+from nemo.collections.asr.data import audio_to_label
+from nemo.collections.asr.data.audio_to_text_dataset import convert_to_config_list, get_chain_dataset
+from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
+from nemo.collections.common.data.dataset import ConcatDataset
+
+
+def get_classification_label_dataset(featurizer, config: dict) -> audio_to_label.AudioToClassificationLabelDataset:
+    """
+    Instantiates a Classification AudioLabelDataset.
+
+    Args:
+        config: Config of the AudioToClassificationLabelDataset.
+
+    Returns:
+        An instance of AudioToClassificationLabelDataset.
+    """
+    dataset = audio_to_label.AudioToClassificationLabelDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config['labels'],
+        featurizer=featurizer,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        trim=config.get('trim_silence', False),
+        is_regression_task=config.get('is_regression_task', False),
+        cal_labels_occurrence=config.get('cal_labels_occurrence', False),
+    )
+    return dataset
+
+
+def get_speech_label_dataset(featurizer, config: dict) -> audio_to_label.AudioToSpeechLabelDataset:
+    """
+    Instantiates a Speech Label (e.g. VAD, speaker recognition) AudioLabelDataset.
+
+    Args:
+        config: Config of the AudioToSpeechLabelDataSet.
+
+    Returns:
+        An instance of AudioToSpeechLabelDataset.
+    """
+    dataset = audio_to_label.AudioToSpeechLabelDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config['labels'],
+        featurizer=featurizer,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        trim=config.get('trim_silence', False),
+        window_length_in_sec=config.get('window_length_in_sec', 0.31),
+        shift_length_in_sec=config.get('shift_length_in_sec', 0.01),
+        normalize_audio=config.get('normalize_audio', False),
+        cal_labels_occurrence=config.get('cal_labels_occurrence', False),
+    )
+    return dataset
+
+
+def get_tarred_classification_label_dataset(
+    featurizer, config: dict, shuffle_n: int, global_rank: int, world_size: int
+) -> audio_to_label.TarredAudioToClassificationLabelDataset:
+    """
+    Instantiates a Classification TarredAudioLabelDataset.
+
+    Args:
+        config: Config of the TarredAudioToClassificationLabelDataset.
+        shuffle_n: How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+
+    Returns:
+        An instance of TarredAudioToClassificationLabelDataset.
+    """
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    tarred_audio_filepaths = convert_to_config_list(tarred_audio_filepaths)
+    manifest_filepaths = convert_to_config_list(manifest_filepaths)
+
+    bucketing_weights = config.get('bucketing_weights', None)  # For upsampling buckets
+    if bucketing_weights:
+        for idx, weight in enumerate(bucketing_weights):
+            if not isinstance(weight, int) or weight <= 0:
+                raise ValueError(f"bucket weights must be positive integers")
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of buckets."
+        )
+
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        if len(tarred_audio_filepath) == 1:
+            tarred_audio_filepath = tarred_audio_filepath[0]
+        dataset = audio_to_label.TarredAudioToClassificationLabelDataset(
+            audio_tar_filepaths=tarred_audio_filepath,
+            manifest_filepath=manifest_filepath,
+            labels=config['labels'],
+            featurizer=featurizer,
+            shuffle_n=shuffle_n,
+            max_duration=config.get('max_duration', None),
+            min_duration=config.get('min_duration', None),
+            trim=config.get('trim_silence', False),
+            shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+            global_rank=global_rank,
+            world_size=world_size,
+            is_regression_task=config.get('is_regression_task', False),
+        )
+
+        if bucketing_weights:
+            [datasets.append(dataset) for _ in range(bucketing_weights[dataset_idx])]
+        else:
+            datasets.append(dataset)
+
+    return get_chain_dataset(datasets=datasets, ds_config=config, rank=global_rank)
+
+
+def get_concat_tarred_speech_label_dataset(
+    featurizer, config: dict, shuffle_n: int, global_rank: int, world_size: int,
+):
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+        conf['tarred_audio_filepaths'] = tarred_audio_filepath
+        dataset = get_tarred_speech_label_dataset(
+            config=conf, featurizer=featurizer, shuffle_n=shuffle_n, global_rank=global_rank, world_size=world_size,
+        )
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        global_rank=global_rank,
+        world_size=world_size,
+        shuffle=config['shuffle'],
+    )
+    return dataset
+
+
+def get_tarred_speech_label_dataset(
+    featurizer, config: dict, shuffle_n: int, global_rank: int, world_size: int,
+) -> audio_to_label.TarredAudioToSpeechLabelDataset:
+    """
+    InInstantiates a Speech Label (e.g. VAD, speaker recognition) TarredAudioLabelDataset.
+
+    Args:
+        config: Config of the TarredAudioToSpeechLabelDataset.
+        shuffle_n: How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+
+    Returns:
+        An instance of TarredAudioToSpeechLabelDataset.
+    """
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    tarred_audio_filepaths = convert_to_config_list(tarred_audio_filepaths)
+    manifest_filepaths = convert_to_config_list(manifest_filepaths)
+
+    bucketing_weights = config.get('bucketing_weights', None)  # For upsampling buckets
+    if bucketing_weights:
+        for idx, weight in enumerate(bucketing_weights):
+            if not isinstance(weight, int) or weight <= 0:
+                raise ValueError(f"bucket weights must be positive integers")
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of buckets."
+        )
+
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        if len(tarred_audio_filepath) == 1:
+            tarred_audio_filepath = tarred_audio_filepath[0]
+        dataset = audio_to_label.TarredAudioToSpeechLabelDataset(
+            audio_tar_filepaths=tarred_audio_filepath,
+            manifest_filepath=manifest_filepath,
+            labels=config['labels'],
+            featurizer=featurizer,
+            shuffle_n=shuffle_n,
+            max_duration=config.get('max_duration', None),
+            min_duration=config.get('min_duration', None),
+            trim=config.get('trim_silence', False),
+            window_length_in_sec=config.get('window_length_in_sec', 8),
+            shift_length_in_sec=config.get('shift_length_in_sec', 0.075),
+            normalize_audio=config.get('normalize_audio', False),
+            shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+            global_rank=global_rank,
+            world_size=world_size,
+        )
+
+        if bucketing_weights:
+            [datasets.append(dataset) for _ in range(bucketing_weights[dataset_idx])]
+        else:
+            datasets.append(dataset)
+
+    return get_chain_dataset(datasets=datasets, ds_config=config, rank=global_rank)
+
+
+def get_audio_multi_label_dataset(cfg: DictConfig) -> audio_to_label.AudioToMultiLabelDataset:
+    if "augmentor" in cfg:
+        augmentor = process_augmentations(cfg.augmentor)
+    else:
+        augmentor = None
+
+    dataset = audio_to_label.AudioToMultiLabelDataset(
+        manifest_filepath=cfg.get("manifest_filepath"),
+        sample_rate=cfg.get("sample_rate"),
+        labels=cfg.get("labels", None),
+        int_values=cfg.get("int_values", False),
+        augmentor=augmentor,
+        min_duration=cfg.get("min_duration", None),
+        max_duration=cfg.get("max_duration", None),
+        trim_silence=cfg.get("trim_silence", False),
+        is_regression_task=cfg.get("is_regression_task", False),
+        cal_labels_occurrence=cfg.get("cal_labels_occurrence", False),
+        delimiter=cfg.get("delimiter", None),
+        normalize_audio_db=cfg.get("normalize_audio_db", None),
+    )
+    return dataset
+
+
+def get_tarred_audio_multi_label_dataset(
+    cfg: DictConfig, shuffle_n: int, global_rank: int, world_size: int
+) -> audio_to_label.TarredAudioToMultiLabelDataset:
+
+    if "augmentor" in cfg:
+        augmentor = process_augmentations(cfg.augmentor)
+    else:
+        augmentor = None
+
+    tarred_audio_filepaths = cfg['tarred_audio_filepaths']
+    manifest_filepaths = cfg['manifest_filepath']
+    datasets = []
+    tarred_audio_filepaths = convert_to_config_list(tarred_audio_filepaths)
+    manifest_filepaths = convert_to_config_list(manifest_filepaths)
+
+    bucketing_weights = cfg.get('bucketing_weights', None)  # For upsampling buckets
+    if bucketing_weights:
+        for idx, weight in enumerate(bucketing_weights):
+            if not isinstance(weight, int) or weight <= 0:
+                raise ValueError(f"bucket weights must be positive integers")
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of buckets."
+        )
+
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        if len(tarred_audio_filepath) == 1:
+            tarred_audio_filepath = tarred_audio_filepath[0]
+
+        dataset = audio_to_label.TarredAudioToMultiLabelDataset(
+            audio_tar_filepaths=tarred_audio_filepath,
+            manifest_filepath=manifest_filepath,
+            sample_rate=cfg["sample_rate"],
+            labels=cfg['labels'],
+            shuffle_n=shuffle_n,
+            int_values=cfg.get("int_values", False),
+            augmentor=augmentor,
+            min_duration=cfg.get('min_duration', None),
+            max_duration=cfg.get('max_duration', None),
+            trim_silence=cfg.get('trim_silence', False),
+            is_regression_task=cfg.get('is_regression_task', False),
+            delimiter=cfg.get("delimiter", None),
+            shard_strategy=cfg.get('tarred_shard_strategy', 'scatter'),
+            global_rank=global_rank,
+            world_size=world_size,
+            normalize_audio_db=cfg.get("normalize_audio_db", None),
+        )
+
+        if bucketing_weights:
+            [datasets.append(dataset) for _ in range(bucketing_weights[dataset_idx])]
+        else:
+            datasets.append(dataset)
+
+    return get_chain_dataset(datasets=datasets, ds_config=cfg, rank=global_rank)

nemo/collections/asr/data/audio_to_text.py

@@ -0,0 +1,1404 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 io
+import json
+import math
+import multiprocessing
+import os
+from collections.abc import Iterable as IterableABC
+from typing import Callable, Dict, Iterable, List, Optional, Tuple, Union
+
+import braceexpand
+import numpy as np
+import torch
+import webdataset as wds
+from torch.utils.data import ChainDataset
+from tqdm import tqdm
+
+from nemo.collections.asr.parts.preprocessing.features import WaveformFeaturizer
+from nemo.collections.asr.parts.preprocessing.segment import ChannelSelectorType
+from nemo.collections.asr.parts.preprocessing.segment import available_formats as valid_sf_formats
+from nemo.collections.common import tokenizers
+from nemo.collections.common.parts.preprocessing import collections, parsers
+from nemo.core.classes import Dataset, IterableDataset
+from nemo.core.neural_types import *
+from nemo.utils import logging
+from nemo.utils.data_utils import (
+    DataStoreObject,
+    datastore_object_get,
+    datastore_path_to_webdataset_url,
+    is_datastore_cache_shared,
+    is_datastore_path,
+    is_tarred_path,
+)
+from nemo.utils.decorators import deprecated
+from nemo.utils.distributed import webdataset_split_by_workers
+from nemo.utils.get_rank import is_global_rank_zero
+
+__all__ = [
+    'AudioToCharDataset',
+    'AudioToBPEDataset',
+    'TarredAudioToCharDataset',
+    'TarredAudioToBPEDataset',
+]
+
+VALID_FILE_FORMATS = ';'.join(['wav', 'mp3', 'flac', 'opus'] + [fmt.lower() for fmt in valid_sf_formats.keys()])
+
+
+def _speech_collate_fn(batch, pad_id):
+    """collate batch of audio sig, audio len, tokens, tokens len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+               LongTensor):  A tuple of tuples of signal, signal lengths,
+               encoded tokens, and encoded tokens length.  This collate func
+               assumes the signals are 1d torch tensors (i.e. mono audio).
+    """
+    packed_batch = list(zip(*batch))
+    if len(packed_batch) == 5:
+        _, audio_lengths, _, tokens_lengths, sample_ids = packed_batch
+    elif len(packed_batch) == 4:
+        sample_ids = None
+        _, audio_lengths, _, tokens_lengths = packed_batch
+    else:
+        raise ValueError("Expects 4 or 5 tensors in the batch!")
+    max_audio_len = 0
+    has_audio = audio_lengths[0] is not None
+    if has_audio:
+        max_audio_len = max(audio_lengths).item()
+    has_tokens = tokens_lengths[0] is not None
+    if has_tokens:
+        max_tokens_len = max(tokens_lengths).item()
+
+    audio_signal, tokens = [], []
+    for b in batch:
+        if len(b) == 5:
+            sig, sig_len, tokens_i, tokens_i_len, _ = b
+        else:
+            sig, sig_len, tokens_i, tokens_i_len = b
+        if has_audio:
+            sig_len = sig_len.item()
+            if sig_len < max_audio_len:
+                pad = (0, max_audio_len - sig_len)
+                sig = torch.nn.functional.pad(sig, pad)
+            audio_signal.append(sig)
+        if has_tokens:
+            tokens_i_len = tokens_i_len.item()
+            if tokens_i_len < max_tokens_len:
+                pad = (0, max_tokens_len - tokens_i_len)
+                tokens_i = torch.nn.functional.pad(tokens_i, pad, value=pad_id)
+            tokens.append(tokens_i)
+
+    if has_audio:
+        audio_signal = torch.stack(audio_signal)
+        audio_lengths = torch.stack(audio_lengths)
+    else:
+        audio_signal, audio_lengths = None, None
+    if has_tokens:
+        tokens = torch.stack(tokens)
+        tokens_lengths = torch.stack(tokens_lengths)
+    else:
+        tokens = None
+        tokens_lengths = None
+    if sample_ids is None:
+        return audio_signal, audio_lengths, tokens, tokens_lengths
+    else:
+        sample_ids = torch.tensor(sample_ids, dtype=torch.int32)
+        return audio_signal, audio_lengths, tokens, tokens_lengths, sample_ids
+
+
+class ASRManifestProcessor:
+    """
+    Class that processes a manifest json file containing paths to audio files, transcripts, and durations (in seconds).
+    Each new line is a different sample. Example below:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath": "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+    Args:
+        manifest_filepath: Path to manifest json as described above. Can be comma-separated paths.
+        parser: Str for a language specific preprocessor or a callable.
+        max_duration: If audio exceeds this length, do not include in dataset.
+        min_duration: If audio is less than this length, do not include in dataset.
+        max_utts: Limit number of utterances.
+        bos_id: Id of beginning of sequence symbol to append if not None.
+        eos_id: Id of end of sequence symbol to append if not None.
+        pad_id: Id of pad symbol. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        parser: Union[str, Callable],
+        max_duration: Optional[float] = None,
+        min_duration: Optional[float] = None,
+        max_utts: int = 0,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        index_by_file_id: bool = False,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        self.parser = parser
+
+        self.collection = collections.ASRAudioText(
+            manifests_files=manifest_filepath,
+            parser=parser,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            max_number=max_utts,
+            index_by_file_id=index_by_file_id,
+            parse_func=manifest_parse_func,
+        )
+
+        self.eos_id = eos_id
+        self.bos_id = bos_id
+        self.pad_id = pad_id
+
+    def process_text_by_id(self, index: int) -> Tuple[List[int], int]:
+        sample = self.collection[index]
+        return self.process_text_by_sample(sample)
+
+    def process_text_by_file_id(self, file_id: str) -> Tuple[List[int], int]:
+        manifest_idx = self.collection.mapping[file_id][0]
+        sample = self.collection[manifest_idx]
+        return self.process_text_by_sample(sample)
+
+    def process_text_by_sample(self, sample: collections.ASRAudioText.OUTPUT_TYPE) -> Tuple[List[int], int]:
+        t, tl = sample.text_tokens, len(sample.text_tokens)
+
+        if self.bos_id is not None:
+            t = [self.bos_id] + t
+            tl += 1
+        if self.eos_id is not None:
+            t = t + [self.eos_id]
+            tl += 1
+
+        return t, tl
+
+
+def expand_sharded_filepaths(sharded_filepaths, shard_strategy: str, world_size: int, global_rank: int):
+    valid_shard_strategies = ['scatter', 'replicate']
+    if shard_strategy not in valid_shard_strategies:
+        raise ValueError(f"`shard_strategy` must be one of {valid_shard_strategies}")
+
+    if isinstance(sharded_filepaths, str):
+        # Replace '(' and '[' with '{'
+        brace_keys_open = ['(', '[', '<', '_OP_']
+        for bkey in brace_keys_open:
+            if bkey in sharded_filepaths:
+                sharded_filepaths = sharded_filepaths.replace(bkey, "{")
+
+        # Replace ')' and ']' with '}'
+        brace_keys_close = [')', ']', '>', '_CL_']
+        for bkey in brace_keys_close:
+            if bkey in sharded_filepaths:
+                sharded_filepaths = sharded_filepaths.replace(bkey, "}")
+
+    if isinstance(sharded_filepaths, str):
+        # Brace expand, set escape=False for Windows compatibility
+        sharded_filepaths = list(braceexpand.braceexpand(sharded_filepaths, escape=False))
+
+    # Expand store paths into WebDataset URLs
+    sharded_filepaths = [
+        datastore_path_to_webdataset_url(p) if is_datastore_path(p) and is_tarred_path(p) else p
+        for p in sharded_filepaths
+    ]
+
+    # Check for distributed and partition shards accordingly
+    if world_size > 1:
+        if shard_strategy == 'scatter':
+            logging.info("All tarred dataset shards will be scattered evenly across all nodes.")
+
+            if len(sharded_filepaths) % world_size != 0:
+                logging.warning(
+                    f"Number of shards in tarred dataset ({len(sharded_filepaths)}) is not divisible "
+                    f"by number of distributed workers ({world_size})."
+                )
+
+            begin_idx = (len(sharded_filepaths) // world_size) * global_rank
+            end_idx = begin_idx + len(sharded_filepaths) // world_size
+            sharded_filepaths = sharded_filepaths[begin_idx:end_idx]
+            logging.info(
+                "Partitioning tarred dataset: process (%d) taking shards [%d, %d)", global_rank, begin_idx, end_idx
+            )
+
+        elif shard_strategy == 'replicate':
+            logging.info("All tarred dataset shards will be replicated across all nodes.")
+        else:
+            raise ValueError(f"Invalid shard strategy ! Allowed values are : {valid_shard_strategies}")
+
+    return sharded_filepaths
+
+
+def cache_datastore_manifests(
+    manifest_filepaths: Union[str, List[str]],
+    cache_audio: bool = False,
+    shared_cache: Optional[bool] = None,
+    num_workers: Optional[int] = None,
+    max_num_workers: int = 20,
+):
+    """Cache manifests and audio from an object store.
+    It is assumed that remote manifests are using relative paths.
+
+    Args:
+        manifest_filepaths: list of paths to manifest files (list of strings or a string with `,` as separator)
+        cache_audio: If True, audio from manifest will also be cached
+        shared_cache: Optional, True if cache is shared across all nodes
+        num_workers: Optional, number of workers to be used for download
+        max_num_workers: max number of workers to be used for download, used when setting num_workers automatically
+    """
+    if isinstance(manifest_filepaths, str):
+        manifest_filepaths = manifest_filepaths.split(',')
+
+    num_datastore_manifests = sum([is_datastore_path(f) for f in manifest_filepaths])
+
+    if num_datastore_manifests > 0:
+        # Local utility function
+        def cache_data(manifest_filepaths, cache_audio, num_workers, max_num_workers):
+            """Cache manifests and audio data from object store."""
+            # Determine the number of workers to use
+            if num_workers is None:
+                num_workers = os.cpu_count() - 1
+            num_workers = min(num_workers, max_num_workers)
+
+            # Process each manifest file
+            for manifest_file in manifest_filepaths:
+                # If manifest is on a data store, then cache it.
+                # Otherwise, nothing to do.
+                if is_datastore_path(manifest_file):
+                    logging.info('Cache manifest file: %s', manifest_file)
+                    cached_manifest_file = DataStoreObject(manifest_file).get()
+                    logging.info('Cached at: %s', str(cached_manifest_file))
+
+                    if cache_audio:
+                        # Each audio file from manifest will be cached.
+                        logging.info('Cache audio from manifest file: %s', manifest_file)
+                        # Assumes that manifest is using relative paths
+                        manifest_dir = os.path.dirname(manifest_file)
+                        # Prepare all store objects
+                        audio_objects = []
+                        with open(cached_manifest_file, 'r') as f:
+                            for line in f:
+                                item = json.loads(line)
+                                store_path = os.path.join(manifest_dir, item['audio_filepath'])
+                                audio_objects.append(DataStoreObject(store_path=store_path))
+
+                        if num_workers is not None and num_workers > 1:
+                            logging.debug('Using multiprocessing with num_workers: %d.', num_workers)
+                            with multiprocessing.Pool(processes=num_workers) as p:
+                                result = list(
+                                    tqdm(p.imap(datastore_object_get, audio_objects), total=len(audio_objects))
+                                )
+                        else:
+                            logging.debug('Using a single process.')
+                            result = []
+                            for audio_object in tqdm(audio_objects):
+                                result.append(audio_object.get() is not None)
+
+                        if not all(result):
+                            raise RuntimeError('Some files not downloaded successfully')
+                        logging.info('Caching complete')
+
+                else:
+                    # Nothing to do here
+                    logging.debug('Manifest is not on a data store: %s', manifest_file)
+
+        if torch.distributed.is_available() and torch.distributed.is_initialized():
+            logging.debug('Distributed environment is available and initialized.')
+
+            # Handle distributed environment
+            if shared_cache is None:
+                shared_cache = is_datastore_cache_shared()
+
+            if shared_cache:
+                logging.debug('Cache is shared among nodes, cache data on global rank zero.')
+                is_rank_zero = is_global_rank_zero()
+            else:
+                logging.debug('Cache is not shared among nodes, cache data on local rank zero.')
+                local_rank = int(os.environ.get("LOCAL_RANK", 0))
+                is_rank_zero = local_rank == 0
+
+            if is_rank_zero:
+                logging.info('Cache data from %s rank 0', 'global' if shared_cache else 'local')
+                cache_data(
+                    manifest_filepaths=manifest_filepaths,
+                    cache_audio=cache_audio,
+                    num_workers=num_workers,
+                    max_num_workers=max_num_workers,
+                )
+            logging.debug('Reached barrier')
+            torch.distributed.barrier()
+
+        elif is_global_rank_zero():
+            # Handle non-distributed environment, e.g., if running on a single GPU
+            logging.warning(
+                'Torch distributed is not initialized and caching may be prone to data race conditions. '
+                'Now caching data from global rank 0. If there are other ranks and they pass this '
+                'before rank 0, errors might result.'
+            )
+            cache_data(
+                manifest_filepaths=manifest_filepaths,
+                cache_audio=cache_audio,
+                num_workers=num_workers,
+                max_num_workers=max_num_workers,
+            )
+        else:
+            raise RuntimeError(
+                'Torch distributed is not initialized and caching on nodes other than global rank zero is disabled '
+                'to avoid race condition between different ranks. To ensure distributed environment is '
+                'initialized, please update data config to use `defer_setup = True`.'
+            )
+
+
+"""Optionally expand / shard the list of manifests
+    This is made to use the same notation as the sharded audio files
+
+    Args:
+        manifest_filepaths: list of manifest files (the sharded notation)
+        shard_strategy: scatter or replicate (scatter by default)
+        shard_manifests: bool, if False, no sharding / manifest filepath expansion will be attempted
+        global_rank: int, the rank of this worker
+        world_size: int, total number of workers
+"""
+
+
+def shard_manifests_if_needed(
+    manifest_filepaths: Union[str, List[str]],
+    shard_strategy: str,
+    shard_manifests: bool,
+    global_rank: int,
+    world_size: int,
+):
+    if shard_manifests:
+        if not torch.distributed.is_available():
+            logging.warning("Not running in torch.distributed mode. Manifest sharding not available")
+            return manifest_filepaths
+
+        if not torch.distributed.is_initialized():
+            logging.warning(
+                'Manifest sharding was requested but torch.distributed is not initialized '
+                'Did you intend to set the defer_setup flag?'
+            )
+            return manifest_filepaths
+
+        manifest_filepaths = expand_sharded_filepaths(
+            sharded_filepaths=manifest_filepaths,
+            shard_strategy=shard_strategy,
+            world_size=world_size,
+            global_rank=global_rank,
+        )
+
+    return manifest_filepaths
+
+
+class _AudioTextDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio files, transcripts, and durations (in seconds).
+    Each new line is a different sample. Example below:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath": "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+    Args:
+        manifest_filepath: Path to manifest json as described above. Can be comma-separated paths.
+        parser: Str for a language specific preprocessor or a callable.
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor object used to augment loaded
+            audio
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include in dataset
+        max_utts: Limit number of utterances
+        trim: whether or not to trim silence. Defaults to False
+        bos_id: Id of beginning of sequence symbol to append if not None
+        eos_id: Id of end of sequence symbol to append if not None
+        pad_id: Id of pad symbol. Defaults to 0
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        parser: Union[str, Callable],
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        max_duration: Optional[int] = None,
+        min_duration: Optional[int] = None,
+        max_utts: int = 0,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        if type(manifest_filepath) == str:
+            manifest_filepath = manifest_filepath.split(",")
+
+        # If necessary, cache manifests and audio from object store
+        cache_datastore_manifests(manifest_filepaths=manifest_filepath, cache_audio=True)
+
+        self.manifest_processor = ASRManifestProcessor(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            manifest_parse_func=manifest_parse_func,
+        )
+        self.featurizer = WaveformFeaturizer(sample_rate=sample_rate, int_values=int_values, augmentor=augmentor)
+        self.trim = trim
+        self.return_sample_id = return_sample_id
+        self.channel_selector = channel_selector
+
+    def get_manifest_sample(self, sample_id):
+        return self.manifest_processor.collection[sample_id]
+
+    def __getitem__(self, index):
+        if isinstance(index, IterableABC):
+            return [self._process_sample(_index) for _index in index]
+        else:
+            return self._process_sample(index)
+
+    def _process_sample(self, index):
+        sample = self.manifest_processor.collection[index]
+        offset = sample.offset
+
+        if offset is None:
+            offset = 0
+
+        features = self.featurizer.process(
+            sample.audio_file,
+            offset=offset,
+            duration=sample.duration,
+            trim=self.trim,
+            orig_sr=sample.orig_sr,
+            channel_selector=self.channel_selector,
+        )
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        t, tl = self.manifest_processor.process_text_by_sample(sample=sample)
+
+        if self.return_sample_id:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long(), index
+        else:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long()
+
+        return output
+
+    def __len__(self):
+        return len(self.manifest_processor.collection)
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=self.manifest_processor.pad_id)
+
+
+class AudioToCharDataset(_AudioTextDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio
+    files, transcripts, and durations (in seconds). Each new line is a
+    different sample. Example below:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath":
+    "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the
+    transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    Args:
+        manifest_filepath: Path to manifest json as described above. Can
+            be comma-separated paths.
+        labels: String containing all the possible characters to map to
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include
+            in dataset
+        max_utts: Limit number of utterances
+        blank_index: blank character index, default = -1
+        unk_index: unk_character index, default = -1
+        normalize: whether to normalize transcript text (default): True
+        bos_id: Id of beginning of sequence symbol to append if not None
+        eos_id: Id of end of sequence symbol to append if not None
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        labels: Union[str, List[str]],
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        max_duration: Optional[float] = None,
+        min_duration: Optional[float] = None,
+        max_utts: int = 0,
+        blank_index: int = -1,
+        unk_index: int = -1,
+        normalize: bool = True,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        parser: Union[str, Callable] = 'en',
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            sample_rate=sample_rate,
+            int_values=int_values,
+            augmentor=augmentor,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+            manifest_parse_func=manifest_parse_func,
+        )
+
+
+class AudioToBPEDataset(_AudioTextDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio
+    files, transcripts, and durations (in seconds). Each new line is a
+    different sample. Example below:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath":
+    "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the
+    transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    In practice, the dataset and manifest used for character encoding and byte pair encoding
+    are exactly the same. The only difference lies in how the dataset tokenizes the text in
+    the manifest.
+
+    Args:
+        manifest_filepath: Path to manifest json as described above. Can
+            be comma-separated paths.
+        tokenizer: A subclass of the Tokenizer wrapper found in the common collection,
+            nemo.collections.common.tokenizers.TokenizerSpec. ASR Models support a subset of
+            all available tokenizers.
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include
+            in dataset
+        max_utts: Limit number of utterances
+        trim: Whether to trim silence segments
+        use_start_end_token: Boolean which dictates whether to add [BOS] and [EOS]
+            tokens to beginning and ending of speech respectively.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        max_duration: Optional[int] = None,
+        min_duration: Optional[int] = None,
+        max_utts: int = 0,
+        trim: bool = False,
+        use_start_end_token: bool = True,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        if use_start_end_token and hasattr(tokenizer, "bos_id") and tokenizer.bos_id > 0:
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, "eos_id") and tokenizer.eos_id > 0:
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, "pad_id") and tokenizer.pad_id > 0:
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                if isinstance(tokenizer, tokenizers.aggregate_tokenizer.AggregateTokenizer):
+                    self.is_aggregate = True
+                else:
+                    self.is_aggregate = False
+                self._tokenizer = tokenizer
+
+            def __call__(self, *args):
+                if isinstance(args[0], List) and self.is_aggregate:
+                    t = []
+                    for span in args[0]:
+                        t.extend(self._tokenizer.text_to_ids(span['str'], span['lang']))
+                    return t
+
+                t = self._tokenizer.text_to_ids(*args)
+                return t
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            parser=TokenizerWrapper(tokenizer),
+            sample_rate=sample_rate,
+            int_values=int_values,
+            augmentor=augmentor,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            trim=trim,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+            manifest_parse_func=manifest_parse_func,
+        )
+
+
+@deprecated(
+    explanation='Webdataset support will be removed in v2.1.0 versions, please use LhotseSpeechToTextBpeDataset class instead'
+)
+class _TarredAudioToTextDataset(IterableDataset):
+    """
+    A similar Dataset to the AudioToCharDataset/AudioToBPEDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToCharDataset/AudioToBPEDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    Note: For brace expansion in (1), there may be cases where `{x..y}` syntax cannot be used due to shell interference.
+    This occurs most commonly inside SLURM scripts. Therefore we provide a few equivalent replacements.
+    Supported opening braces - { <=> (, [, < and the special tag _OP_.
+    Supported closing braces - } <=> ), ], > and the special tag _CL_.
+    For SLURM based tasks, we suggest the use of the special tags for ease of use.
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple workers the number of shards should be divisible by world_size to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToCharDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        parser (callable): A callable which is used to pre-process the text output.
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        blank_index (int): Blank character index, defaults to -1.
+        unk_index (int): Unknown character index, defaults to -1.
+        normalize (bool): Dataset parameter.
+            Whether to use automatic text cleaning.
+            It is highly recommended to manually clean text for best results.
+            Defaults to True.
+        trim (bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        bos_id (id): Dataset parameter.
+            Beginning of string symbol id used for seq2seq models.
+            Defaults to None.
+        eos_id (id): Dataset parameter.
+            End of string symbol id used for seq2seq models.
+            Defaults to None.
+        pad_id (id): Token used to pad when collating samples in batches.
+            If this is None, pads using 0s.
+            Defaults to None.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+        shard_manifests (bool): Whether or not to try / shard manifests. Defaults to False.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: str,
+        parser: Callable,
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: Optional['nemo.collections.asr.parts.perturb.AudioAugmentor'] = None,
+        shuffle_n: int = 0,
+        min_duration: Optional[float] = None,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        shard_strategy: str = "scatter",
+        shard_manifests: bool = False,
+        global_rank: int = 0,
+        world_size: int = 0,
+        return_sample_id: bool = False,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        self.shard_manifests = shard_manifests
+
+        # Shard manifests if necessary and possible and then expand the paths
+        manifest_filepath = shard_manifests_if_needed(
+            shard_manifests=shard_manifests,
+            shard_strategy=shard_strategy,
+            manifest_filepaths=manifest_filepath,
+            world_size=world_size,
+            global_rank=global_rank,
+        )
+
+        # If necessary, cache manifests from object store
+        cache_datastore_manifests(manifest_filepaths=manifest_filepath)
+
+        self.manifest_processor = ASRManifestProcessor(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=0,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            index_by_file_id=True,  # Must set this so the manifest lines can be indexed by file ID
+            manifest_parse_func=manifest_parse_func,
+        )
+
+        self.len = self._compute_len()
+
+        self.featurizer = WaveformFeaturizer(sample_rate=sample_rate, int_values=int_values, augmentor=augmentor)
+        self.trim = trim
+        self.eos_id = eos_id
+        self.bos_id = bos_id
+        self.pad_id = pad_id
+        self.return_sample_id = return_sample_id
+
+        audio_tar_filepaths = expand_sharded_filepaths(
+            sharded_filepaths=audio_tar_filepaths,
+            shard_strategy=shard_strategy,
+            world_size=world_size,
+            global_rank=global_rank,
+        )
+
+        # Put together WebDataset pipeline
+        self._dataset = wds.DataPipeline(
+            wds.SimpleShardList(urls=audio_tar_filepaths),
+            webdataset_split_by_workers,
+            wds.shuffle(shuffle_n),
+            wds.tarfile_to_samples(),
+            wds.rename(audio=VALID_FILE_FORMATS, key='__key__'),
+            wds.to_tuple('audio', 'key'),
+            self._filter,
+            self._loop_offsets,
+            wds.map(self._build_sample),
+        )
+
+    def _filter(self, iterator):
+        """This function is used to remove samples that have been filtered out by ASRAudioText already.
+        Otherwise, we would get a KeyError as _build_sample attempts to find the manifest entry for a sample
+        that was filtered out (e.g. for duration).
+        Note that if using multi-GPU training, filtering may lead to an imbalance in samples in each shard,
+        which may make your code hang as one process will finish before the other.
+        """
+
+        class TarredAudioFilter:
+            def __init__(self, collection):
+                self.iterator = iterator
+                self.collection = collection
+
+            def __iter__(self):
+                return self
+
+            def __next__(self):
+                while True:
+                    audio_bytes, audio_filename = next(self.iterator)
+                    file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+                    if file_id in self.collection.mapping:
+                        return audio_bytes, audio_filename
+
+        return TarredAudioFilter(self.manifest_processor.collection)
+
+    def _loop_offsets(self, iterator):
+        """This function is used to iterate through utterances with different offsets for each file."""
+
+        class TarredAudioLoopOffsets:
+            def __init__(self, collection):
+                self.iterator = iterator
+                self.collection = collection
+                self.current_fn = None
+                self.current_bytes = None
+                self.offset_id = 0
+
+            def __iter__(self):
+                return self
+
+            def __next__(self):
+                if self.current_fn is None:
+                    self.current_bytes, self.current_fn = next(self.iterator)
+                    self.offset_id = 0
+                else:
+                    import os
+                    file_id, _ = os.path.splitext(os.path.basename(self.current_fn))
+                    offset_list = self.collection.mapping[file_id]
+                    if len(offset_list) == self.offset_id + 1:
+                        self.current_bytes, self.current_fn = next(self.iterator)
+                        self.offset_id = 0
+                    else:
+                        self.offset_id += 1
+
+                return self.current_bytes, self.current_fn, self.offset_id
+
+        return TarredAudioLoopOffsets(self.manifest_processor.collection)
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, self.pad_id)
+
+    def _build_sample(self, tup):
+        """Builds the training sample by combining the data from the WebDataset with the manifest info."""
+        audio_bytes, audio_filename, offset_id = tup
+
+        # Grab manifest entry from self.manifest_preprocessor.collection
+        file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+
+        manifest_idx = self.manifest_processor.collection.mapping[file_id][offset_id]
+        manifest_entry = self.manifest_processor.collection[manifest_idx]
+
+        offset = manifest_entry.offset
+        if offset is None:
+            offset = 0
+
+        # Convert audio bytes to IO stream for processing (for SoundFile to read)
+        audio_filestream = io.BytesIO(audio_bytes)
+        features = self.featurizer.process(
+            audio_filestream,
+            offset=offset,
+            duration=manifest_entry.duration,
+            trim=self.trim,
+            orig_sr=manifest_entry.orig_sr,
+        )
+        audio_filestream.close()
+
+        # Audio features
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        # Text features
+        t, tl = manifest_entry.text_tokens, len(manifest_entry.text_tokens)
+
+        self.manifest_processor.process_text_by_sample(sample=manifest_entry)
+
+        if self.bos_id is not None:
+            t = [self.bos_id] + t
+            tl += 1
+        if self.eos_id is not None:
+            t = t + [self.eos_id]
+            tl += 1
+
+        if self.return_sample_id:
+            return f, fl, torch.tensor(t).long(), torch.tensor(tl).long(), manifest_idx
+        else:
+            return f, fl, torch.tensor(t).long(), torch.tensor(tl).long()
+
+    def get_manifest_sample(self, sample_id):
+        return self.manifest_processor.collection[sample_id]
+
+    def __iter__(self):
+        return self._dataset.__iter__()
+
+    def _compute_len(self):
+        if self.shard_manifests and torch.distributed.is_available() and torch.distributed.is_initialized():
+            my_len = torch.tensor(len(self.manifest_processor.collection), dtype=torch.int32).cuda()
+            torch.distributed.all_reduce(my_len)
+            my_len = my_len.int()
+            logging.info(f'Sharded manifests: Total length: {my_len}')
+        else:
+            my_len = len(self.manifest_processor.collection)
+
+        return my_len
+
+    def __len__(self):
+        return self.len
+
+
+class TarredAudioToCharDataset(_TarredAudioToTextDataset):
+    """
+    A similar Dataset to the AudioToCharDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToCharDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple workers the number of shards should be divisible by world_size to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToCharDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        labels (list): List of characters that can be output by the ASR model.
+            For Jasper, this is the 28 character set {a-z '}. The CTC blank
+            symbol is automatically added later for models using ctc.
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        blank_index (int): Blank character index, defaults to -1.
+        unk_index (int): Unknown character index, defaults to -1.
+        normalize (bool): Dataset parameter.
+            Whether to use automatic text cleaning.
+            It is highly recommended to manually clean text for best results.
+            Defaults to True.
+        trim (bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        bos_id (id): Dataset parameter.
+            Beginning of string symbol id used for seq2seq models.
+            Defaults to None.
+        eos_id (id): Dataset parameter.
+            End of string symbol id used for seq2seq models.
+            Defaults to None.
+        pad_id (id): Token used to pad when collating samples in batches.
+            If this is None, pads using 0s.
+            Defaults to None.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: str,
+        labels: List[str],
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: Optional['nemo.collections.asr.parts.perturb.AudioAugmentor'] = None,
+        shuffle_n: int = 0,
+        min_duration: Optional[float] = None,
+        max_duration: Optional[float] = None,
+        blank_index: int = -1,
+        unk_index: int = -1,
+        normalize: bool = True,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        parser: Optional[str] = 'en',
+        pad_id: int = 0,
+        shard_strategy: str = "scatter",
+        shard_manifests: bool = False,
+        global_rank: int = 0,
+        world_size: int = 0,
+        return_sample_id: bool = False,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            audio_tar_filepaths=audio_tar_filepaths,
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            sample_rate=sample_rate,
+            int_values=int_values,
+            augmentor=augmentor,
+            shuffle_n=shuffle_n,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            shard_strategy=shard_strategy,
+            shard_manifests=shard_manifests,
+            global_rank=global_rank,
+            world_size=world_size,
+            return_sample_id=return_sample_id,
+            manifest_parse_func=manifest_parse_func,
+        )
+
+
+class TarredAudioToBPEDataset(_TarredAudioToTextDataset):
+    """
+    A similar Dataset to the AudioToBPEDataset, but which loads tarred audio files.
+
+    Accepts a single comma-separated JSON manifest file (in the same style as for the AudioToBPEDataset),
+    as well as the path(s) to the tarball(s) containing the wav files. Each line of the manifest should
+    contain the information for one audio file, including at least the transcript and name of the audio
+    file within the tarball.
+
+    Valid formats for the audio_tar_filepaths argument include:
+    (1) a single string that can be brace-expanded, e.g. 'path/to/audio.tar' or 'path/to/audio_{1..100}.tar.gz', or
+    (2) a list of file paths that will not be brace-expanded, e.g. ['audio_1.tar', 'audio_2.tar', ...].
+
+    See the WebDataset documentation for more information about accepted data and input formats.
+
+    If using multiple workers the number of shards should be divisible by world_size to ensure an
+    even split among workers. If it is not divisible, logging will give a warning but training will proceed.
+    In addition, if using mutiprocessing, each shard MUST HAVE THE SAME NUMBER OF ENTRIES after filtering
+    is applied. We currently do not check for this, but your program may hang if the shards are uneven!
+
+    Notice that a few arguments are different from the AudioToBPEDataset; for example, shuffle (bool) has been
+    replaced by shuffle_n (int).
+
+    Additionally, please note that the len() of this DataLayer is assumed to be the length of the manifest
+    after filtering. An incorrect manifest length may lead to some DataLoader issues down the line.
+
+    Args:
+        audio_tar_filepaths: Either a list of audio tarball filepaths, or a
+            string (can be brace-expandable).
+        manifest_filepath (str): Path to the manifest.
+        tokenizer (TokenizerSpec): Either a Word Piece Encoding tokenizer (BERT),
+            or a Sentence Piece Encoding tokenizer (BPE). The CTC blank
+            symbol is automatically added later for models using ctc.
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        shuffle_n (int): How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+            Defaults to 0.
+        min_duration (float): Dataset parameter.
+            All training files which have a duration less than min_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to 0.1.
+        max_duration (float): Dataset parameter.
+            All training files which have a duration more than max_duration
+            are dropped. Note: Duration is read from the manifest JSON.
+            Defaults to None.
+        trim (bool): Whether to use trim silence from beginning and end
+            of audio signal using librosa.effects.trim().
+            Defaults to False.
+        use_start_end_token: Boolean which dictates whether to add [BOS] and [EOS]
+            tokens to beginning and ending of speech respectively.
+        pad_id (id): Token used to pad when collating samples in batches.
+            If this is None, pads using 0s.
+            Defaults to None.
+        shard_strategy (str): Tarred dataset shard distribution strategy chosen as a str value during ddp.
+
+            -   `scatter`: The default shard strategy applied by WebDataset, where each node gets
+                a unique set of shards, which are permanently pre-allocated and never changed at runtime.
+            -   `replicate`: Optional shard strategy, where each node gets all of the set of shards
+                available in the tarred dataset, which are permanently pre-allocated and never changed at runtime.
+                The benefit of replication is that it allows each node to sample data points from the entire
+                dataset independently of other nodes, and reduces dependence on value of `shuffle_n`.
+
+                .. warning::
+
+                    Replicated strategy allows every node to sample the entire set of available tarfiles,
+                    and therefore more than one node may sample the same tarfile, and even sample the same
+                    data points! As such, there is no assured guarantee that all samples in the dataset will be
+                    sampled at least once during 1 epoch. Scattered strategy, on the other hand, on specific
+                    occasions (when the number of shards is not divisible with ``world_size``), will not sample
+                    the entire dataset. For these reasons it is not advisable to use tarred datasets as validation
+                    or test datasets.
+
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 0.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        manifest_parse_func: Optional function to parse manifest entries. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        audio_tar_filepaths: Union[str, List[str]],
+        manifest_filepath: str,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        sample_rate: int,
+        int_values: bool = False,
+        augmentor: Optional['nemo.collections.asr.parts.perturb.AudioAugmentor'] = None,
+        shuffle_n: int = 0,
+        min_duration: Optional[float] = None,
+        max_duration: Optional[float] = None,
+        trim: bool = False,
+        use_start_end_token: bool = True,
+        shard_strategy: str = "scatter",
+        shard_manifests: bool = False,
+        global_rank: int = 0,
+        world_size: int = 0,
+        return_sample_id: bool = False,
+        manifest_parse_func: Optional[Callable] = None,
+    ):
+        if use_start_end_token and hasattr(tokenizer, "bos_id") and tokenizer.bos_id > 0:
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, "eos_id") and tokenizer.eos_id > 0:
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, "pad_id") and tokenizer.pad_id > 0:
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                if isinstance(tokenizer, tokenizers.aggregate_tokenizer.AggregateTokenizer):
+                    self.is_aggregate = True
+                else:
+                    self.is_aggregate = False
+                self._tokenizer = tokenizer
+
+            def __call__(self, *args):
+                if isinstance(args[0], List) and self.is_aggregate:
+                    t = []
+                    for span in args[0]:
+                        t.extend(self._tokenizer.text_to_ids(span['str'], span['lang']))
+                    return t
+
+                t = self._tokenizer.text_to_ids(*args)
+                return t
+
+        super().__init__(
+            audio_tar_filepaths=audio_tar_filepaths,
+            manifest_filepath=manifest_filepath,
+            parser=TokenizerWrapper(tokenizer),
+            sample_rate=sample_rate,
+            int_values=int_values,
+            augmentor=augmentor,
+            shuffle_n=shuffle_n,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            shard_strategy=shard_strategy,
+            shard_manifests=shard_manifests,
+            global_rank=global_rank,
+            world_size=world_size,
+            return_sample_id=return_sample_id,
+            manifest_parse_func=manifest_parse_func,
+        )
+
+
+class BucketingDataset(IterableDataset):
+    """
+    A Dataset which wraps another IterableDataset and adopts it for bucketing
+    Args:
+        dataset (IterableDataset): The IterableDataset to get wrapped
+        bucketing_batch_size (int): Number of samples to build a batch
+    """
+
+    def __init__(
+        self,
+        dataset: IterableDataset,
+        bucketing_batch_size: int,
+    ):
+        self.wrapped_dataset = dataset
+        self.bucketing_batch_size = bucketing_batch_size
+        super().__init__()
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch[0], self.wrapped_dataset.pad_id)
+
+    def __iter__(self):
+        return BucketingIterator(
+            wrapped_ds=self.wrapped_dataset._dataset, bucketing_batch_size=self.bucketing_batch_size
+        ).__iter__()
+
+    def __len__(self):
+        return int(math.ceil(len(self.wrapped_dataset) / float(self.bucketing_batch_size)))
+
+
+class BucketingIterator:
+    def __init__(self, wrapped_ds, bucketing_batch_size):
+        self.wrapped_ds = wrapped_ds
+        self.wrapped_iter = None
+        self.bucketing_batch_size = bucketing_batch_size
+
+    def __iter__(self):
+        self.wrapped_iter = iter(self.wrapped_ds)
+        return self
+
+    def __next__(self):
+        batches = []
+        for idx in range(self.bucketing_batch_size):
+            try:
+                sample = next(self.wrapped_iter)
+            except StopIteration:
+                break
+            batches.append(sample)
+        if len(batches) == 0:
+            raise StopIteration
+        return batches
+
+
+class RandomizedChainDataset(ChainDataset):
+    def __init__(self, datasets: Iterable[Dataset], rnd_seed=0) -> None:
+        super(RandomizedChainDataset, self).__init__(list(datasets))
+        self.rnd_gen = np.random.RandomState(rnd_seed)
+
+    def __iter__(self):
+        shuffled_order = self.rnd_gen.permutation(len(self.datasets))
+        for dataset_idx in shuffled_order:
+            d = self.datasets[dataset_idx]
+            assert isinstance(d, IterableDataset), "ChainDataset only supports IterableDataset"
+            for idx, x in enumerate(d):
+                yield x
+                # in case d is an infinite dataset, we want to break the loop
+                # so that the other datasets get a chance to yield too
+                if idx >= len(d) - 1:
+                    break

nemo/collections/asr/data/audio_to_text_dali.py

@@ -0,0 +1,772 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 math
+import operator
+import os.path
+import time
+from collections.abc import Iterator
+from typing import Callable, List, Optional, Union
+
+import torch
+from omegaconf import DictConfig
+
+from nemo.collections.asr.data.audio_to_text import ASRManifestProcessor, expand_sharded_filepaths
+from nemo.collections.common.parts.preprocessing import parsers
+from nemo.utils import logging, model_utils
+
+try:
+    import nvidia.dali as dali
+    from nvidia.dali.pipeline import Pipeline
+    from nvidia.dali.plugin.pytorch import DALIGenericIterator as DALIPytorchIterator
+    from nvidia.dali.plugin.pytorch import LastBatchPolicy as LastBatchPolicy
+
+    HAVE_DALI = True
+except (ImportError, ModuleNotFoundError):
+    HAVE_DALI = False
+
+__all__ = [
+    'AudioToCharDALIDataset',
+    'AudioToBPEDALIDataset',
+]
+
+"""
+Below minimum version is required to access the "read_idxs" argument in
+dali.fn.readers.nemo_asr
+"""
+__DALI_MINIMUM_VERSION__ = "1.11"
+
+DALI_INSTALLATION_MESSAGE = (
+    "Could not import `nvidia.dali`.\n"
+    "Please install DALI by following the steps provided here - \n"
+    "https://docs.nvidia.com/deeplearning/dali/user-guide/docs/installation.html"
+)
+
+
+def is_dali_supported(min_version: str, verbose: bool = False) -> bool:
+    """
+    Checks if DALI in installed, and version is >= min_verion.
+
+    Args:
+        min_version: A semver str that is the minimum requirement.
+        verbose: Whether to log the installation instructions if DALI is not found.
+
+    Returns:
+        bool - whether DALI could be imported or not.
+    """
+    module_available, _ = model_utils.check_lib_version(
+        'nvidia.dali', checked_version=min_version, operator=operator.ge
+    )
+
+    # If DALI is not installed
+    if module_available is None:
+        if verbose:
+            logging.info(DALI_INSTALLATION_MESSAGE)
+
+        return False
+
+    return module_available
+
+
+class DALIOutputs(object):
+    def __init__(self, out_dict):
+        self._has_processed_signal = 'processed_signal' in out_dict and 'processed_signal_len' in out_dict
+        if not self._has_processed_signal:
+            assert 'audio' in out_dict and 'audio_len' in out_dict
+        assert 'transcript' in out_dict and 'transcript_len' in out_dict
+        if self._has_processed_signal:
+            self._outs = (
+                out_dict['processed_signal'],
+                out_dict['processed_signal_len'].reshape(-1),
+                out_dict['transcript'],
+                out_dict['transcript_len'].reshape(-1),
+            )
+        else:
+            self._outs = (
+                out_dict['audio'],
+                out_dict['audio_len'].reshape(-1),
+                out_dict['transcript'],
+                out_dict['transcript_len'].reshape(-1),
+            )
+
+    @property
+    def has_processed_signal(self):
+        return self._has_processed_signal
+
+    def __getitem__(self, key):
+        return self._outs[key]
+
+    def __len__(self):
+        return len(self._outs)
+
+
+class _AudioTextDALIDataset(Iterator):
+    """
+    NVIDIA DALI pipeline that loads tensors via one or more manifest files where each line containing a sample descriptor in JSON,
+    including audio files, transcripts, and durations (in seconds).
+    Here's an example:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath": "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    Args:
+        manifest_filepath: Path to manifest file with the format described above. Can be comma-separated paths.
+        device (str): Determines the device type to be used for preprocessing. Allowed values are: 'cpu', 'gpu'.
+        batch_size (int): Number of samples in a batch.
+        parser (str, callable): A str for an inbuilt parser, or a callable with signature f(str) -> List[int].
+        sample_rate (int): Sample rate to resample loaded audio to.
+        num_threads (int): Number of CPU processing threads to be created by the DALI pipeline.
+        max_duration (float): Determines the maximum allowed duration, in seconds, of the loaded audio files.
+        min_duration (float): Determines the minimum allowed duration, in seconds, of the loaded audio files.
+        bos_id (int): Id of beginning of sequence symbol to append if not None
+        eos_id (int): Id of end of sequence symbol to append if not None
+        pad_id (int): Id used to pad the input. Defaults to 0 if not provided.
+        trim (bool): If True, it will extract the nonsilent region of the loaded audio signal.
+        shuffle (bool): If set to True, the dataset will shuffled after loading.
+        drop_last (bool): If set to True, the last batch will be dropped if incomplete. This will be the case when the shard size is not divisible by the batch size.
+                          If set to False and the size of dataset is not divisible by the batch size, then the last batch will be smaller.
+        device_id (int): Index of the GPU to be used (local_rank). Only applicable when device == 'gpu'. Defaults to 0.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 1.
+        preprocessor_cfg (DictConfig): Preprocessor configuration. Supports AudioToMelSpectrogramPreprocessor and AudioToMFCCPreprocessor.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample (not supported yet).
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        device: str,
+        batch_size: int,
+        parser: Union[str, Callable],
+        audio_tar_filepaths: Optional[Union[str, List[str]]] = None,
+        audio_tar_index_filepaths: Optional[Union[str, List[str]]] = None,
+        sample_rate: int = 16000,
+        num_threads: int = 4,
+        max_duration: float = 0.0,
+        min_duration: float = 0.0,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        trim: bool = False,
+        shuffle: bool = False,
+        drop_last: bool = False,
+        shard_strategy: str = "scatter",
+        device_id: int = 0,
+        global_rank: int = 0,
+        world_size: int = 1,
+        preprocessor_cfg: DictConfig = None,
+        return_sample_id: bool = False,
+    ):
+        self.drop_last = drop_last  # used by lr_scheduler
+        if return_sample_id:
+            raise ValueError(
+                "Currently DALI data layers don't support returning the sample_id and return_sample_id can not be enabled."
+            )
+        self.return_sample_id = return_sample_id
+
+        if not HAVE_DALI:
+            raise ModuleNotFoundError(
+                f"{self} requires NVIDIA DALI to be installed. "
+                f"See: https://docs.nvidia.com/deeplearning/dali/user-guide/docs/installation.html#id1"
+            )
+
+        if device not in ('cpu', 'gpu'):
+            raise ValueError(
+                f"{self} received an unexpected device argument {device}. Supported values are: 'cpu', 'gpu'"
+            )
+
+        device_id = device_id if device == 'gpu' else None
+
+        self.batch_size = batch_size  # Used by NeMo
+
+        self.device = device
+        self.device_id = device_id
+
+        if world_size > 1:
+            self.shard_id = global_rank
+            self.num_shards = world_size
+        else:
+            self.shard_id = None
+            self.num_shards = None
+
+        self.eos_id = eos_id
+        self.bos_id = bos_id
+        self.sample_rate = sample_rate
+
+        self.pipe = Pipeline(
+            batch_size=batch_size,
+            num_threads=num_threads,
+            device_id=self.device_id,
+            exec_async=True,
+            exec_pipelined=True,
+        )
+
+        has_preprocessor = preprocessor_cfg is not None
+        if has_preprocessor:
+            if preprocessor_cfg._target_ == "nemo.collections.asr.modules.AudioToMelSpectrogramPreprocessor":
+                feature_type = "mel_spectrogram"
+            elif preprocessor_cfg._target_ == "nemo.collections.asr.modules.AudioToMFCCPreprocessor":
+                feature_type = "mfcc"
+            else:
+                raise ValueError(
+                    f"{self} received an unexpected preprocessor configuration: {preprocessor_cfg._target_}."
+                    f" Supported preprocessors are: AudioToMelSpectrogramPreprocessor, AudioToMFCCPreprocessor"
+                )
+
+            # Default values taken from AudioToMelSpectrogramPreprocessor
+            params = preprocessor_cfg
+            self.dither = params['dither'] if 'dither' in params else 0.0
+            self.preemph = params['preemph'] if 'preemph' in params else 0.97
+            self.window_size_sec = params['window_size'] if 'window_size' in params else 0.02
+            self.window_stride_sec = params['window_stride'] if 'window_stride' in params else 0.01
+            self.sample_rate = params['sample_rate'] if 'sample_rate' in params else sample_rate
+            self.window_size = int(self.window_size_sec * self.sample_rate)
+            self.window_stride = int(self.window_stride_sec * self.sample_rate)
+
+            normalize = params['normalize'] if 'normalize' in params else 'per_feature'
+            if normalize == 'per_feature':  # Each freq channel independently
+                self.normalization_axes = (1,)
+            elif normalize == 'all_features':
+                self.normalization_axes = (0, 1)
+            else:
+                raise ValueError(
+                    f"{self} received {normalize} for the normalize parameter."
+                    f" It must be either 'per_feature' or 'all_features'."
+                )
+
+            self.window = None
+            window_name = params['window'] if 'window' in params else 'hann'
+            torch_windows = {
+                'hann': torch.hann_window,
+                'hamming': torch.hamming_window,
+                'blackman': torch.blackman_window,
+                'bartlett': torch.bartlett_window,
+                'none': None,
+            }
+
+            if window_name == 'ones':
+                window_tensor = torch.ones(self.window_size)
+            else:
+                try:
+                    window_fn = torch_windows.get(window_name, None)
+                except:
+                    raise ValueError(
+                        f"{self} received '{window_name}' for the window parameter."
+                        f" It must be one of: ('hann', 'ones', 'hamming', 'blackman', 'bartlett', None)."
+                        f" None is equivalent to 'hann'."
+                    )
+                window_tensor = window_fn(self.window_size, periodic=False) if window_fn else None
+            self.window = window_tensor.numpy().tolist() if window_tensor is not None else None
+
+            self.n_fft = params['n_fft'] if 'n_fft' in params else 2 ** math.ceil(math.log2(self.window_size))
+            self.n_mels = params['n_mels'] if 'n_mels' in params else 64
+            self.n_mfcc = params['n_mfcc'] if 'n_mfcc' in params else 64
+
+            features = params['features'] if 'features' in params else 0
+            if features > 0:
+                if feature_type == 'mel_spectrogram':
+                    self.n_mels = features
+                elif feature_type == 'mfcc':
+                    self.n_mfcc = features
+
+            # TODO Implement frame splicing
+            if 'frame_splicing' in params:
+                assert params['frame_splicing'] == 1, "Frame splicing is not implemented"
+
+            self.freq_low = params['lowfreq'] if 'lowfreq' in params else 0.0
+            self.freq_high = params['highfreq'] if 'highfreq' in params else self.sample_rate / 2.0
+            self.log_features = params['log'] if 'log' in params else True
+
+            # We want to avoid taking the log of zero
+            # There are two options: either adding or clamping to a small value
+
+            self.log_zero_guard_type = params['log_zero_guard_type'] if 'log_zero_guard_type' in params else 'add'
+            if self.log_zero_guard_type not in ["add", "clamp"]:
+                raise ValueError(
+                    f"{self} received {self.log_zero_guard_type} for the "
+                    f"log_zero_guard_type parameter. It must be either 'add' or "
+                    f"'clamp'."
+                )
+
+            self.log_zero_guard_value = (
+                params['log_zero_guard_value'] if 'log_zero_guard_value' in params else 2 ** -24
+            )
+            if isinstance(self.log_zero_guard_value, str):
+                if self.log_zero_guard_value == "tiny":
+                    self.log_zero_guard_value = torch.finfo(torch.float32).tiny
+                elif self.log_zero_guard_value == "eps":
+                    self.log_zero_guard_value = torch.finfo(torch.float32).eps
+                else:
+                    raise ValueError(
+                        f"{self} received {self.log_zero_guard_value} for the log_zero_guard_type parameter."
+                        f"It must be either a number, 'tiny', or 'eps'"
+                    )
+
+            self.mag_power = params['mag_power'] if 'mag_power' in params else 2
+            if self.mag_power != 1.0 and self.mag_power != 2.0:
+                raise ValueError(
+                    f"{self} received {self.mag_power} for the mag_power parameter." f" It must be either 1.0 or 2.0."
+                )
+
+            self.pad_to = max(params['pad_to'], 1) if 'pad_to' in params else 16
+            self.pad_value = params['pad_value'] if 'pad_value' in params else 0.0
+
+        with self.pipe:
+            if audio_tar_filepaths is None and audio_tar_index_filepaths is None:
+                audio, indices = dali.fn.readers.nemo_asr(
+                    name="Reader",
+                    manifest_filepaths=manifest_filepath.split(','),
+                    dtype=dali.types.FLOAT,
+                    downmix=True,
+                    sample_rate=float(self.sample_rate),
+                    min_duration=min_duration,
+                    max_duration=max_duration,
+                    read_sample_rate=False,
+                    read_text=False,
+                    read_idxs=True,
+                    random_shuffle=shuffle,
+                    shard_id=self.shard_id,
+                    num_shards=self.num_shards,
+                    pad_last_batch=True,
+                )
+
+                self.is_tarred_dataset = False
+
+            elif audio_tar_filepaths is not None and audio_tar_index_filepaths is not None:
+                audio_tar_filepaths = expand_sharded_filepaths(
+                    audio_tar_filepaths, shard_strategy=shard_strategy, world_size=world_size, global_rank=global_rank
+                )
+                audio_tar_index_filepaths = expand_sharded_filepaths(
+                    audio_tar_index_filepaths,
+                    shard_strategy=shard_strategy,
+                    world_size=world_size,
+                    global_rank=global_rank,
+                )
+
+                if len(audio_tar_filepaths) != len(audio_tar_index_filepaths) and len(audio_tar_index_filepaths) != 0:
+                    raise ValueError(
+                        f"Number of filepaths provided for `audio_tar_filepaths` must match "
+                        f"`audio_tar_index_filepaths`. Got {len(audio_tar_filepaths)} audio_tar_filepaths and "
+                        f"{len(audio_tar_index_filepaths)} audio_tar_index_filepaths."
+                    )
+
+                tar_file = dali.fn.readers.webdataset(
+                    paths=audio_tar_filepaths,
+                    index_paths=audio_tar_index_filepaths,
+                    name="Reader",
+                    ext=["wav"],
+                    missing_component_behavior="error",
+                    random_shuffle=shuffle,
+                    shard_id=self.shard_id,
+                    num_shards=self.num_shards,
+                    pad_last_batch=True,
+                )
+                audio, _ = dali.fn.decoders.audio(
+                    tar_file, dtype=dali.types.FLOAT, downmix=True, sample_rate=float(self.sample_rate),
+                )
+                indices = dali.fn.get_property(tar_file, key="source_info")
+                indices = dali.fn.pad(indices)
+
+                self.is_tarred_dataset = True
+
+            else:
+                raise RuntimeError(
+                    "When using DALI datasets, either `audio_tar_filepaths` "
+                    "and `audio_tar_index_filepaths` should either both be None (sequential dataset)"
+                    "or provided (tarred dataset)."
+                )
+
+            # Extract nonsilent region, if necessary
+            if trim:
+                # Need to extract non-silent region before moving to the GPU
+                roi_start, roi_len = dali.fn.nonsilent_region(audio, cutoff_db=-60)
+                audio = audio.gpu() if self.device == 'gpu' else audio
+                audio = dali.fn.slice(
+                    audio, roi_start, roi_len, normalized_anchor=False, normalized_shape=False, axes=[0]
+                )
+            else:
+                audio = audio.gpu() if self.device == 'gpu' else audio
+
+            if not has_preprocessor:
+                # No preprocessing, the output is the audio signal
+                audio_len = dali.fn.shapes(dali.fn.reshape(audio, shape=[-1]))
+                audio = dali.fn.pad(audio)
+                self.pipe.set_outputs(audio, audio_len, indices)
+            else:
+                # Additive gaussian noise (dither)
+                if self.dither > 0.0:
+                    gaussian_noise = dali.fn.random.normal(audio)
+                    audio = audio + self.dither * gaussian_noise
+
+                # Preemphasis filter
+                if self.preemph > 0.0:
+                    audio = dali.fn.preemphasis_filter(audio, preemph_coeff=self.preemph, border='zero')
+
+                # Power spectrogram
+                spec = dali.fn.spectrogram(
+                    audio,
+                    nfft=self.n_fft,
+                    window_length=self.window_size,
+                    window_step=self.window_stride,
+                    window_fn=self.window,
+                )
+
+                if feature_type == 'mel_spectrogram' or feature_type == 'mfcc':
+                    # Spectrogram to Mel Spectrogram
+                    spec = dali.fn.mel_filter_bank(
+                        spec,
+                        sample_rate=self.sample_rate,
+                        nfilter=self.n_mels,
+                        normalize=True,
+                        freq_low=self.freq_low,
+                        freq_high=self.freq_high,
+                    )
+                    # Mel Spectrogram to MFCC
+                    if feature_type == 'mfcc':
+                        spec = dali.fn.mfcc(spec, n_mfcc=self.n_mfcc)
+
+                # Logarithm
+                if self.log_zero_guard_type == 'add':
+                    spec = spec + self.log_zero_guard_value
+
+                spec = dali.fn.to_decibels(
+                    spec, multiplier=math.log(10), reference=1.0, cutoff_db=math.log(self.log_zero_guard_value)
+                )
+
+                # Normalization
+                spec = dali.fn.normalize(spec, axes=self.normalization_axes, epsilon=1e-5 ** 2, ddof=1)
+
+                # Extracting the length of the spectrogram
+                spec_len = dali.fn.slice(dali.fn.shapes(spec), 1, 1, axes=(0,))
+
+                # Pads feature dimension to be a multiple of `pad_to` and the temporal dimension to be as big as the largest sample (shape -1)
+                spec = dali.fn.pad(spec, fill_value=self.pad_value, axes=(0, 1), align=(self.pad_to, 1), shape=(1, -1))
+                self.pipe.set_outputs(spec, spec_len, indices)
+
+        x = time.time()
+        # Building DALI pipeline
+        self.pipe.build()
+        y = time.time()
+
+        logging.info(f"Time for pipe.build() : {(y - x)} seconds")
+
+        if has_preprocessor:
+            output_names = ['processed_signal', 'processed_signal_len', 'manifest_indices']
+        else:
+            output_names = ['audio', 'audio_len', 'manifest_indices']
+
+        x = time.time()
+        last_batch_policy = LastBatchPolicy.DROP if drop_last else LastBatchPolicy.PARTIAL
+        self._iter = DALIPytorchIterator(
+            [self.pipe],
+            output_map=output_names,
+            reader_name="Reader",
+            last_batch_policy=last_batch_policy,
+            dynamic_shape=True,
+            auto_reset=True,
+        )
+        y = time.time()
+        logging.info(f"Time for DALIPytorchIterator to initialize : {(y - x)} seconds")
+
+        # TODO come up with a better solution
+        class DummyDataset:
+            def __init__(self, parent):
+                self.parent = parent
+
+            def __len__(self):
+                return self.parent.size
+
+        self.dataset = DummyDataset(self)  # Used by NeMo
+
+        x = time.time()
+        self.manifest_processor = ASRManifestProcessor(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=0,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            index_by_file_id=self.is_tarred_dataset,
+        )
+        y = time.time()
+        logging.info(f"Time to build nemo manifest processor - {(y - x)} seconds")
+
+    def reset(self):
+        self._iter.reset()
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        return self.__next__()
+
+    @property
+    def size(self):
+        return self._iter.size
+
+    def __len__(self):
+        return len(self._iter)
+
+    def __next__(self):
+        outputs = self._iter.next()
+        assert len(outputs) == 1
+        dali_out = outputs[0]
+        manifest_indices = dali_out['manifest_indices'].numpy()
+
+        out = {}
+        out_names = ['processed_signal', 'processed_signal_len', 'audio', 'audio_len']
+        for out_name in out_names:
+            if out_name in dali_out:
+                out[out_name] = dali_out[out_name].detach().clone()
+
+        text_tokens = []
+        text_tokens_len = []
+        max_len = 0
+        batch_size = manifest_indices.shape[0]
+        for i, manifest_index in enumerate(manifest_indices):
+
+            if not self.is_tarred_dataset:
+                # Loose-file dataset. Index is integer based.
+                manifest_index = manifest_index[0]
+                text, text_length = self.manifest_processor.process_text_by_id(manifest_index)
+            else:
+                # Tarred-file dataset. Index is filename based.
+                resolved_manifest_indices = manifest_index.tobytes().decode().split(":")
+                resolved_manifest_index = resolved_manifest_indices[2]  # we require just the filename segment
+                resolved_manifest_index = os.path.splitext(resolved_manifest_index)[0]  # we dont need file extension
+                text, text_length = self.manifest_processor.process_text_by_file_id(resolved_manifest_index)
+
+            text_tokens_len.append(text_length)
+            text_tokens.append(text)
+            if text_length > max_len:
+                max_len = text_length
+
+        transcript_out = torch.full([batch_size, max_len], fill_value=self.manifest_processor.pad_id, dtype=torch.long)
+        for i, n in enumerate(text_tokens_len):
+            transcript_out[i, :n] = torch.tensor(text_tokens[i], dtype=torch.long)
+        transcript_len_out = torch.tensor(text_tokens_len, dtype=torch.long)
+
+        out['transcript'] = transcript_out
+        out['transcript_len'] = transcript_len_out
+        return DALIOutputs(out)
+
+
+class AudioToCharDALIDataset(_AudioTextDALIDataset):
+    """
+    Character based NVIDIA DALI pipeline that loads tensors via one or more manifest files where each line containing a
+    sample descriptor in JSON, including audio files, transcripts, and durations (in seconds).
+    Here's an example:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath": "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    Args:
+        manifest_filepath: Path to manifest file with the format described above. Can be comma-separated paths.
+        device (str): Determines the device type to be used for preprocessing. Allowed values are: 'cpu', 'gpu'.
+        batch_size (int): Number of samples in a batch.
+        labels (List[str]): String containing all the possible characters to map to.
+        sample_rate (int): Sample rate to resample loaded audio to.
+        num_threads (int): Number of CPU processing threads to be created by the DALI pipeline.
+        max_duration (float): Determines the maximum allowed duration, in seconds, of the loaded audio files.
+        min_duration (float): Determines the minimum allowed duration, in seconds, of the loaded audio files.
+        blank_index (int): blank character index, default = -1
+        unk_index (int): unk_character index, default = -1
+        normalize (bool): whether to normalize transcript text (default): True
+        bos_id (int): Id of beginning of sequence symbol to append if not None
+        eos_id (int): Id of end of sequence symbol to append if not None
+        pad_id (int): Id used to pad the input. Defaults to 0 if not provided.
+        trim (bool): If True, it will extract the nonsilent region of the loaded audio signal.
+        shuffle (bool): If set to True, the dataset will shuffled after loading.
+        drop_last (bool): If set to True, the last batch will be dropped if incomplete. This will be the case when the shard size is not divisible by the batch size.
+                          If set to False and the size of dataset is not divisible by the batch size, then the last batch will be smaller.
+        parser (str, callable): A str for an inbuilt parser, or a callable with signature f(str) -> List[int].
+        device_id (int): Index of the GPU to be used (local_rank). Only applicable when device == 'gpu'. Defaults to 0.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 1.
+        preprocessor_cfg (DictConfig): Preprocessor configuration. Supports AudioToMelSpectrogramPreprocessor and AudioToMFCCPreprocessor.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample (not supported yet).
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        device: str,
+        batch_size: int,
+        labels: Union[str, List[str]],
+        sample_rate: int = 16000,
+        audio_tar_filepaths: Optional[Union[str, List[str]]] = None,
+        audio_tar_index_filepaths: Optional[Union[str, List[str]]] = None,
+        num_threads: int = 4,
+        max_duration: float = 0.0,
+        min_duration: float = 0.0,
+        blank_index: int = -1,
+        unk_index: int = -1,
+        normalize: bool = True,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        trim: bool = False,
+        shuffle: bool = False,
+        drop_last: bool = False,
+        parser: Union[str, Callable] = 'en',
+        shard_strategy: str = "scatter",
+        device_id: int = 0,
+        global_rank: int = 0,
+        world_size: int = 1,
+        preprocessor_cfg: DictConfig = None,
+        return_sample_id: bool = False,
+    ):
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            device=device,
+            batch_size=batch_size,
+            audio_tar_filepaths=audio_tar_filepaths,
+            audio_tar_index_filepaths=audio_tar_index_filepaths,
+            sample_rate=sample_rate,
+            num_threads=num_threads,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            trim=trim,
+            shuffle=shuffle,
+            drop_last=drop_last,
+            parser=parser,
+            shard_strategy=shard_strategy,
+            device_id=device_id,
+            global_rank=global_rank,
+            world_size=world_size,
+            preprocessor_cfg=preprocessor_cfg,
+            return_sample_id=return_sample_id,
+        )
+
+
+class AudioToBPEDALIDataset(_AudioTextDALIDataset):
+    """
+    Subword based NVIDIA DALI pipeline that loads tensors via one or more manifest files where each line containing a
+    sample descriptor in JSON, including audio files, transcripts, and durations (in seconds).
+    Here's an example:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath": "/path/to/audio.txt", "duration": 23.147}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    Args:
+        manifest_filepath: Path to manifest file with the format described above. Can be comma-separated paths.
+        tokenizer (TokenizerSpec): A TokenizerSpec implementation that wraps a tokenization implementation.
+        device (str): Determines the device type to be used for preprocessing. Allowed values are: 'cpu', 'gpu'.
+        batch_size (int): Number of samples in a batch.
+        sample_rate (int): Sample rate to resample loaded audio to.
+        num_threads (int): Number of CPU processing threads to be created by the DALI pipeline.
+        max_duration (float): Determines the maximum allowed duration, in seconds, of the loaded audio files.
+        min_duration (float): Determines the minimum allowed duration, in seconds, of the loaded audio files.
+        bos_id (int): Id of beginning of sequence symbol to append if not None. Injected from the tokenizer.
+        eos_id (int): Id of end of sequence symbol to append if not None. Injected from the tokenizer.
+        pad_id (int): Id used to pad the input. Defaults to 0 if not provided. Injected from the tokenizer.
+        trim (bool): If True, it will extract the nonsilent region of the loaded audio signal.
+        shuffle (bool): If set to True, the dataset will shuffled after loading.
+        drop_last (bool): If set to True, the last batch will be dropped if incomplete. This will be the case when the shard size is not divisible by the batch size.
+                          If set to False and the size of dataset is not divisible by the batch size, then the last batch will be smaller.
+
+        device_id (int): Index of the GPU to be used (local_rank). Only applicable when device == 'gpu'. Defaults to 0.
+        global_rank (int): Worker rank, used for partitioning shards. Defaults to 0.
+        world_size (int): Total number of processes, used for partitioning shards. Defaults to 1.
+        preprocessor_cfg (DictConfig): Preprocessor configuration. Supports AudioToMelSpectrogramPreprocessor and AudioToMFCCPreprocessor.
+        use_start_end_token (bool): Boolean which dictates whether to add [BOS] and [EOS] tokens to beginning and
+            ending of speech respectively.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample (not supported yet).
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        device: str,
+        batch_size: int,
+        sample_rate: int = 16000,
+        audio_tar_filepaths: Optional[Union[str, List[str]]] = None,
+        audio_tar_index_filepaths: Optional[Union[str, List[str]]] = None,
+        num_threads: int = 4,
+        max_duration: float = 0.0,
+        min_duration: float = 0.0,
+        trim: bool = False,
+        shuffle: bool = False,
+        drop_last: bool = False,
+        shard_strategy: str = "scatter",
+        device_id: int = 0,
+        global_rank: int = 0,
+        world_size: int = 1,
+        preprocessor_cfg: DictConfig = None,
+        use_start_end_token: bool = True,
+        return_sample_id: bool = False,
+    ):
+
+        if use_start_end_token and hasattr(tokenizer, 'bos_token'):
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, 'eos_token'):
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, 'pad_token'):
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                self._tokenizer = tokenizer
+
+            def __call__(self, text):
+                t = self._tokenizer.text_to_ids(text)
+                return t
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            device=device,
+            batch_size=batch_size,
+            sample_rate=sample_rate,
+            audio_tar_filepaths=audio_tar_filepaths,
+            audio_tar_index_filepaths=audio_tar_index_filepaths,
+            num_threads=num_threads,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            trim=trim,
+            shuffle=shuffle,
+            drop_last=drop_last,
+            parser=TokenizerWrapper(tokenizer),
+            shard_strategy=shard_strategy,
+            device_id=device_id,
+            global_rank=global_rank,
+            world_size=world_size,
+            preprocessor_cfg=preprocessor_cfg,
+            return_sample_id=return_sample_id,
+        )

nemo/collections/asr/data/audio_to_text_dataset.py

@@ -0,0 +1,983 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 copy
+import json
+import random
+from math import isclose
+from typing import Any, List, Optional, Union
+
+import torch
+from lightning.pytorch.callbacks import BasePredictionWriter
+from omegaconf import DictConfig, OmegaConf, open_dict
+from omegaconf.listconfig import ListConfig
+from torch.utils.data import ChainDataset
+
+from nemo.collections.asr.data import audio_to_text, audio_to_text_dali
+from nemo.collections.asr.data.huggingface.hf_audio_to_text_dataset import (
+    get_hf_audio_to_text_bpe_dataset,
+    get_hf_audio_to_text_char_dataset,
+)
+from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
+from nemo.collections.common.data.dataset import CodeSwitchedDataset, ConcatDataset
+from nemo.utils import logging
+
+
+def inject_dataloader_value_from_model_config(model_cfg: dict, dataloader_cfg: DictConfig, key: str):
+    """
+    Extracts the label set provided at the top level of the model, and propagates it to the dataloader
+    config.
+
+    Args:
+        model_cfg: A DictConfig representing the model's config.
+        dataloader_cfg: A DictConfig representing the individual data loader
+        key: A str value representing a key in the model_cfg whose value will be propagated to the
+            dataloader config.
+    """
+    if key not in model_cfg:
+        logging.info(
+            f"Model level config does not contain `{key}`, please explicitly provide `{key}` to the dataloaders."
+        )
+        return
+
+    if not isinstance(dataloader_cfg, DictConfig):
+        dataloader_cfg = DictConfig(dataloader_cfg)
+
+    # If key exists in the data loader config (either set explicitly or as a placeholder (via None))
+    if key in dataloader_cfg:
+        # Dataloader `labels` is provided and is non-null
+        if dataloader_cfg[key] is not None and model_cfg[key] != dataloader_cfg[key]:
+            # Model level `labels` dont match Dataloader level `labels`
+            logging.warning(
+                f'`{key}` is explicitly provided to the data loader, and is different from '
+                f'the `{key}` provided at the model level config.\n'
+                f'If this is incorrect, please set the dataloader\'s `{key}` to None.'
+            )
+
+        else:
+            # Dataloader `key` is None or values match
+            # Propagate from model level `key` (even if they match)
+            with open_dict(dataloader_cfg):
+                dataloader_cfg[key] = model_cfg[key]
+
+    else:
+        # If key key doesnt even exist in dataloader_cfg, inject it explicitly
+        with open_dict(dataloader_cfg):
+            dataloader_cfg[key] = model_cfg[key]
+
+
+def get_concat_char_dataset(
+    config: dict, global_rank: int, world_size: int, augmentor: Optional['AudioAugmentor'] = None
+) -> ConcatDataset:
+    """
+    Instantiates an instance of ConcatDataset containing one or more intances of
+    Character Encoding based AudioToCharDataset.
+
+    Args:
+        config: Config of the AudioToCharDataset.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of ConcatDataset containing one or more instances of AudioToCharDataset.
+    """
+    if 'labels' not in config:
+        logging.warning(f"dataset does not have explicitly defined labels")
+
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+
+    # needed to support validation Concat Datasets that arrive here as
+    # [[dataset1,dataset2]] otherwise ModelPT would interfere
+    if len(manifest_filepaths) == 1 and not isinstance(manifest_filepaths[0], str):
+        logging.info(f"removing an extra nesting level from {manifest_filepaths}")
+        manifest_filepaths = config['manifest_filepath'][0]
+
+    for manifest_filepath in manifest_filepaths:
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+
+        dataset = get_char_dataset(config=conf, augmentor=augmentor)
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_scale=config.get('concat_sampling_scale', 1),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        shuffle=config.get('concat_shuffle', True),
+        seed=config.get('concat_sampling_seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+    )
+    return dataset
+
+
+def get_char_dataset(config: dict, augmentor: Optional['AudioAugmentor'] = None) -> audio_to_text.AudioToCharDataset:
+    """
+    Instantiates a Character Encoding based AudioToCharDataset.
+
+    Args:
+        config: Config of the AudioToCharDataset.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of AudioToCharDataset.
+    """
+    if 'labels' not in config:
+        logging.warning(f"dataset does not have explicitly defined labels")
+
+    dataset = audio_to_text.AudioToCharDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config.get('labels', None),
+        sample_rate=config['sample_rate'],
+        int_values=config.get('int_values', False),
+        augmentor=augmentor,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        max_utts=config.get('max_utts', 0),
+        blank_index=config.get('blank_index', -1),
+        unk_index=config.get('unk_index', -1),
+        normalize=config.get('normalize_transcripts', False),
+        trim=config.get('trim_silence', False),
+        parser=config.get('parser', 'en'),
+        return_sample_id=config.get('return_sample_id', False),
+        channel_selector=config.get('channel_selector', None),
+    )
+    return dataset
+
+
+def get_concat_bpe_dataset(
+    config: dict,
+    tokenizer: 'TokenizerSpec',
+    global_rank: int,
+    world_size: int,
+    augmentor: Optional['AudioAugmentor'] = None,
+) -> ConcatDataset:
+    """
+    Instantiates a ContactDataset based on several Byte Pair Encoding / Word Piece Encoding based AudioToBPEDatasets.
+
+    Args:
+        config: Config of the AudioToBPEDataset.
+        tokenizer: An instance of a TokenizerSpec object.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of ConcatDataset containing several instances of AudioToBPEDataset.
+    """
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+
+    # needed to support validation Concat Datasets that arrive here as
+    # [[dataset1,dataset2]] otherwise ModelPT would interfere
+    if len(manifest_filepaths) == 1 and not isinstance(manifest_filepaths[0], str):
+        logging.info(f"removing an extra nesting level from {manifest_filepaths}")
+        manifest_filepaths = config['manifest_filepath'][0]
+
+    for manifest_filepath in manifest_filepaths:
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+        dataset = get_bpe_dataset(config=conf, tokenizer=tokenizer, augmentor=augmentor)
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_scale=config.get('concat_sampling_scale', 1),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        shuffle=config.get('concat_shuffle', True),
+        seed=config.get('concat_sampling_seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+    )
+    return dataset
+
+
+def get_bpe_dataset(
+    config: dict, tokenizer: 'TokenizerSpec', augmentor: Optional['AudioAugmentor'] = None
+) -> audio_to_text.AudioToBPEDataset:
+    """
+    Instantiates a Byte Pair Encoding / Word Piece Encoding based AudioToBPEDataset.
+
+    Args:
+        config: Config of the AudioToBPEDataset.
+        tokenizer: An instance of a TokenizerSpec object.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of AudioToBPEDataset.
+    """
+    dataset = audio_to_text.AudioToBPEDataset(
+        manifest_filepath=config['manifest_filepath'],
+        tokenizer=tokenizer,
+        sample_rate=config['sample_rate'],
+        int_values=config.get('int_values', False),
+        augmentor=augmentor,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        max_utts=config.get('max_utts', 0),
+        trim=config.get('trim_silence', False),
+        use_start_end_token=config.get('use_start_end_token', True),
+        return_sample_id=config.get('return_sample_id', False),
+        channel_selector=config.get('channel_selector', None),
+    )
+    return dataset
+
+
+def get_concat_tarred_dataset(
+    config: dict,
+    shuffle_n: int,
+    global_rank: int,
+    world_size: int,
+    tokenizer: Optional['TokenizerSpec'] = None,
+    augmentor: Optional['AudioAugmentor'] = None,
+) -> ConcatDataset:
+    """
+    Instantiates a ConcatDataset containing multiple Word Piece/BPE Encoding based TarredAudioToBPEDataset or a char based TarredAudioToCharDataset.
+
+    Args:
+        config: Config of the TarredAudioToBPEDataset or TarredAudioToCharDataset.
+        shuffle_n: How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+        tokenizer: An instance of a TokenizerSpec object if BPE dataset is needed.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+            Passsing None would return a char-based dataset.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of ConcatDataset containing one or more TarredAudioToBPEDatasets or TarredAudioToCharDatasets.
+    """
+
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+        conf['tarred_audio_filepaths'] = tarred_audio_filepath
+        dataset = get_tarred_dataset(
+            config=conf,
+            tokenizer=tokenizer,
+            shuffle_n=shuffle_n,
+            global_rank=global_rank,
+            world_size=world_size,
+            augmentor=augmentor,
+        )
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_scale=config.get('concat_sampling_scale', 1),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        shuffle=config.get('concat_shuffle', True),
+        seed=config.get('concat_sampling_seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+    )
+    return dataset
+
+
+def get_tarred_dataset(
+    config: dict,
+    shuffle_n: int,
+    global_rank: int,
+    world_size: int,
+    tokenizer: Optional['TokenizerSpec'] = None,
+    augmentor: Optional['AudioAugmentor'] = None,
+) -> Union[audio_to_text.TarredAudioToBPEDataset, audio_to_text.TarredAudioToCharDataset]:
+    """
+    Instantiates a Word Piece/BPE Encoding based TarredAudioToBPEDataset or a char based TarredAudioToCharDataset.
+
+    Args:
+        config: Config of the TarredAudioToBPEDataset or TarredAudioToCharDataset.
+        shuffle_n: How many samples to look ahead and load to be shuffled.
+            See WebDataset documentation for more details.
+        tokenizer: An instance of a TokenizerSpec object if BPE dataset is needed.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+            Passsing None would return a char-based dataset.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of TarredAudioToBPEDataset or TarredAudioToCharDataset.
+    """
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    tarred_audio_filepaths = convert_to_config_list(tarred_audio_filepaths)
+    manifest_filepaths = convert_to_config_list(manifest_filepaths)
+
+    bucketing_weights = config.get('bucketing_weights', None)  # For upsampling buckets
+    if bucketing_weights:
+        for idx, weight in enumerate(bucketing_weights):
+            if not isinstance(weight, int) or weight <= 0:
+                raise ValueError(f"bucket weights must be positive integers")
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of buckets."
+        )
+
+    if 'labels' not in config:
+        logging.warning(f"dataset does not have explicitly defined labels")
+
+    if 'max_utts' in config:
+        raise ValueError('"max_utts" parameter is not supported for tarred datasets')
+
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        if len(tarred_audio_filepath) == 1:
+            tarred_audio_filepath = tarred_audio_filepath[0]
+        if len(manifest_filepath) == 1:
+            manifest_filepath = manifest_filepath[0]
+
+        if tokenizer is None:
+            dataset = audio_to_text.TarredAudioToCharDataset(
+                audio_tar_filepaths=tarred_audio_filepath,
+                manifest_filepath=manifest_filepath,
+                labels=config.get('labels', None),
+                sample_rate=config['sample_rate'],
+                int_values=config.get('int_values', False),
+                augmentor=augmentor,
+                shuffle_n=shuffle_n,
+                max_duration=config.get('max_duration', None),
+                min_duration=config.get('min_duration', None),
+                blank_index=config.get('blank_index', -1),
+                unk_index=config.get('unk_index', -1),
+                normalize=config.get('normalize_transcripts', False),
+                trim=config.get('trim_silence', False),
+                parser=config.get('parser', 'en'),
+                shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+                shard_manifests=config.get('shard_manifests', False),
+                global_rank=global_rank,
+                world_size=world_size,
+                return_sample_id=config.get('return_sample_id', False),
+            )
+        else:
+            dataset = audio_to_text.TarredAudioToBPEDataset(
+                audio_tar_filepaths=tarred_audio_filepath,
+                manifest_filepath=manifest_filepath,
+                tokenizer=tokenizer,
+                sample_rate=config['sample_rate'],
+                int_values=config.get('int_values', False),
+                augmentor=augmentor,
+                shuffle_n=shuffle_n,
+                max_duration=config.get('max_duration', None),
+                min_duration=config.get('min_duration', None),
+                trim=config.get('trim_silence', False),
+                use_start_end_token=config.get('use_start_end_token', True),
+                shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+                shard_manifests=config.get('shard_manifests', False),
+                global_rank=global_rank,
+                world_size=world_size,
+                return_sample_id=config.get('return_sample_id', False),
+            )
+        if bucketing_weights:
+            [datasets.append(dataset) for _ in range(bucketing_weights[dataset_idx])]
+        else:
+            datasets.append(dataset)
+
+    return get_chain_dataset(datasets=datasets, ds_config=config, rank=global_rank)
+
+
+def get_code_switched_dataset(
+    config: dict,
+    shuffle_n: int,
+    global_rank: int,
+    world_size: int,
+    tokenizer: Optional['TokenizerSpec'] = None,
+    augmentor: Optional['AudioAugmentor'] = None,
+) -> CodeSwitchedDataset:
+
+    if 'manifest_filepath' not in config:
+        raise ValueError("`manifest_filepath` must be provided in the dataset config if `is_code_switched=True`")
+    if 'code_switched' not in config:
+        raise ValueError("`code_switched` param group must be in the dataset config if `is_code_switched=True`")
+
+    manifest_filepaths = config['manifest_filepath']
+    tarred_audio_filepaths = config.get('tarred_audio_filepaths', None)
+
+    cs_config = OmegaConf.to_container(config['code_switched'])
+
+    # needed to support validation Datasets that arrive here as
+    # [[dataset1,dataset2]] otherwise ModelPT would interfere
+    if len(manifest_filepaths) == 1 and not isinstance(manifest_filepaths[0], str):
+        manifest_filepaths = config['manifest_filepath'][0]
+    if tarred_audio_filepaths is None:
+        tarred_audio_filepaths = [None] * len(manifest_filepaths)
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of items."
+        )
+
+    datasets = []
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+        with open_dict(conf):
+            conf['tarred_audio_filepaths'] = tarred_audio_filepath
+        if tarred_audio_filepath is None or len(tarred_audio_filepath) == 0:
+            if tokenizer is None:
+                dataset = get_char_dataset(config=conf, augmentor=None)
+            else:
+                dataset = get_bpe_dataset(config=conf, tokenizer=tokenizer, augmentor=None)
+        else:
+            dataset = get_tarred_dataset(
+                config=conf,
+                tokenizer=tokenizer,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=None,
+            )
+        datasets.append(dataset)
+
+    config = OmegaConf.to_container(config)
+
+    dataset = CodeSwitchedDataset(
+        datasets,
+        shuffle=cs_config.get('shuffle', True),
+        min_duration=cs_config.get('min_duration', 4),
+        max_duration=cs_config.get('max_duration', 20),
+        min_monolingual=cs_config.get('min_monolingual', 0.3),
+        lang_probs=cs_config.get('probs', None),
+        db_norm=cs_config.get('db_norm', -25.0),
+        pause_start=cs_config.get('pause_start', 0),
+        pause_join=cs_config.get('pause_join', 0),
+        pause_end=cs_config.get('pause_end', 0),
+        sampling_scales=cs_config.get('sampling_scales', None),
+        seed=cs_config.get('seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+        pure_random=cs_config.get('pure_random', False),
+        force_monochannel=cs_config.get('force_monochannel', True),
+        infinity_mode=cs_config.get('infinity_mode', False),
+        sample_rate=config['sample_rate'],
+        augmentor=augmentor,
+    )
+
+    return dataset
+
+
+def get_dali_char_dataset(
+    config: dict,
+    shuffle: bool,
+    device_id: int,
+    global_rank: int,
+    world_size: int,
+    preprocessor_cfg: Optional[DictConfig] = None,
+) -> audio_to_text_dali.AudioToCharDALIDataset:
+    """
+    Instantiates a Character Encoding based AudioToCharDALIDataset.
+
+    Args:
+        config: Config of the AudioToCharDALIDataset.
+        shuffle: Bool flag whether to shuffle the dataset.
+        device_id: Index of the GPU to be used (local_rank). Only applicable when device == 'gpu'. Defaults to 0.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+        preprocessor_cfg: Preprocessor configuration. Supports AudioToMelSpectrogramPreprocessor and AudioToMFCCPreprocessor.
+
+    Returns:
+        An instance of AudioToCharDALIDataset.
+    """
+    device = 'gpu' if torch.cuda.is_available() else 'cpu'
+    dataset = audio_to_text_dali.AudioToCharDALIDataset(
+        manifest_filepath=config['manifest_filepath'],
+        device=device,
+        batch_size=config['batch_size'],
+        labels=config['labels'],
+        sample_rate=config['sample_rate'],
+        audio_tar_filepaths=config.get('tarred_audio_filepaths', None),
+        audio_tar_index_filepaths=config.get('tarred_audio_index_filepaths', None),
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        blank_index=config.get('blank_index', -1),
+        unk_index=config.get('unk_index', -1),
+        normalize=config.get('normalize_transcripts', False),
+        trim=config.get('trim_silence', False),
+        parser=config.get('parser', 'en'),
+        shuffle=shuffle,
+        shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+        device_id=device_id,
+        global_rank=global_rank,
+        world_size=world_size,
+        preprocessor_cfg=preprocessor_cfg,
+        return_sample_id=config.get('return_sample_id', False),
+    )
+    return dataset
+
+
+def get_dali_bpe_dataset(
+    config: dict,
+    tokenizer,
+    shuffle: bool,
+    device_id: int,
+    global_rank: int,
+    world_size: int,
+    preprocessor_cfg: Optional[DictConfig] = None,
+) -> audio_to_text_dali.AudioToCharDALIDataset:
+    """
+    Instantiates a Subword Encoding based AudioToBPEDALIDataset.
+
+    Args:
+        config: Config of the AudioToBPEDALIDataset.
+        tokenizer: An implementation of NeMo TokenizerSpec.
+        shuffle: Bool flag whether to shuffle the dataset.
+        device_id: Index of the GPU to be used (local_rank). Only applicable when device == 'gpu'. Defaults to 0.
+        global_rank: Global rank of this device.
+        world_size: Global world size in the training method.
+        preprocessor_cfg: Preprocessor configuration. Supports AudioToMelSpectrogramPreprocessor and AudioToMFCCPreprocessor.
+
+    Returns:
+        An instance of AudioToCharDALIDataset.
+    """
+    device = 'gpu' if torch.cuda.is_available() else 'cpu'
+    dataset = audio_to_text_dali.AudioToBPEDALIDataset(
+        manifest_filepath=config['manifest_filepath'],
+        tokenizer=tokenizer,
+        device=device,
+        batch_size=config['batch_size'],
+        sample_rate=config['sample_rate'],
+        audio_tar_filepaths=config.get('tarred_audio_filepaths', None),
+        audio_tar_index_filepaths=config.get('tarred_audio_index_filepaths', None),
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        trim=config.get('trim_silence', False),
+        use_start_end_token=config.get('use_start_end_token', True),
+        shuffle=shuffle,
+        shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+        device_id=device_id,
+        global_rank=global_rank,
+        world_size=world_size,
+        preprocessor_cfg=preprocessor_cfg,
+        return_sample_id=config.get('return_sample_id', False),
+    )
+    return dataset
+
+
+def get_audio_to_text_char_dataset_from_config(
+    config, local_rank: int, global_rank: int, world_size: int, preprocessor_cfg: Optional[DictConfig] = None
+):
+    """
+    Construct Audio-To-Text Char dataset from a config.
+    Args:
+        config: dataset config
+        local_rank: model local rank
+        global_rank: model global rand
+        world_size: world size
+        preprocessor_cfg: preprocessor config, for DALI dataset
+
+    Returns:
+        constructed dataset or None if dataset config is invalid or nothing to load
+    """
+    if 'augmentor' in config:
+        augmentor = process_augmentations(config['augmentor'], global_rank=global_rank, world_size=world_size)
+    else:
+        augmentor = None
+
+    if 'hf_data_cfg' in config:
+        return get_hf_audio_to_text_char_dataset(
+            config=config, global_rank=global_rank, world_size=world_size, augmentor=augmentor
+        )
+
+    is_concat = config.get('is_concat', False)
+    if is_concat:
+        if 'concat_sampling_technique' in config and config['concat_sampling_technique'] is None:
+            logging.warning(
+                f"Concat dataset requires `concat_sampling_technique` but it was not provided. Config: {config}"
+            )
+            return None
+        if config['concat_sampling_technique'] == 'random':
+            if not 'concat_sampling_probabilities' in config:
+                logging.warning(f"Concat dataset requires `concat_sampling_probabilities` list. Config: {config}")
+                return None
+            else:
+                if not isclose(sum(config['concat_sampling_probabilities']), 1, abs_tol=1e-6):
+                    logging.warning(f"`concat_sampling_probabilities` need to sum to 1. Config: {config}")
+                    return None
+
+    shuffle = config['shuffle']
+    device = 'gpu' if torch.cuda.is_available() else 'cpu'
+    if config.get('use_dali', False):
+        device_id = local_rank if device == 'gpu' else None
+        dataset = get_dali_char_dataset(
+            config=config,
+            shuffle=shuffle,
+            device_id=device_id,
+            global_rank=global_rank,
+            world_size=world_size,
+            preprocessor_cfg=preprocessor_cfg,
+        )
+        return dataset
+
+    # Instantiate a code-switched dataset if config is present
+    if config.get('is_code_switched', False):
+        if 'manifest_filepath' in config and config['manifest_filepath'] is None:
+            logging.warning(f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}")
+            return None
+        if not ('code_switched' in config and config['code_switched'] is not None):
+            logging.warning(
+                f"Code switched dataset requires `*_ds.code_switched.*` dict but it was not provided. Config: {config}"
+            )
+            return None
+        if (
+            ('probs' in config['code_switched'])
+            and (config['code_switched']['probs'] is not None)
+            and (not isclose(sum(config['code_switched']['probs']), 1, abs_tol=1e-6))
+        ):
+            logging.warning(f"`.code_switched.probs` need to sum to 1. Config: {config['code_switched']}")
+            return None
+
+        shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0
+        dataset = get_code_switched_dataset(
+            config=config,
+            shuffle_n=shuffle_n,
+            global_rank=global_rank,
+            world_size=world_size,
+            tokenizer=None,
+            augmentor=augmentor,
+        )
+    # Instantiate tarred dataset loader or normal dataset loader
+    elif config.get('is_tarred', False):
+        if ('tarred_audio_filepaths' in config and config['tarred_audio_filepaths'] is None) or (
+            'manifest_filepath' in config and config['manifest_filepath'] is None
+        ):
+            logging.warning(
+                "Could not load dataset as `manifest_filepath` was None or "
+                f"`tarred_audio_filepaths` is None. Provided config : {config}"
+            )
+            return None
+
+        shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0
+        if is_concat:
+            dataset = get_concat_tarred_dataset(
+                config=config,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+            )
+        else:
+            dataset = get_tarred_dataset(
+                config=config,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+            )
+    else:
+        if 'manifest_filepath' in config and config['manifest_filepath'] is None:
+            logging.warning(f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}")
+            return None
+        if is_concat:
+            dataset = get_concat_char_dataset(
+                config=config, global_rank=global_rank, world_size=world_size, augmentor=augmentor
+            )
+        else:
+            dataset = get_char_dataset(config=config, augmentor=augmentor)
+    return dataset
+
+
+def get_audio_to_text_bpe_dataset_from_config(
+    config,
+    local_rank: int,
+    global_rank: int,
+    world_size: int,
+    tokenizer,
+    preprocessor_cfg: Optional[DictConfig] = None,
+):
+    """
+    Construct Audio-To-Text BPE dataset from a config.
+    Args:
+        config: BPE dataset config
+        local_rank: model local rank
+        global_rank: model global rand
+        world_size: world size
+        tokenizer: BPE tokenizer
+        preprocessor_cfg: preprocessor config, for DALI BPE dataset
+
+    Returns:
+        constructed dataset or None if dataset config is invalid or nothing to load
+    """
+    if 'augmentor' in config:
+        augmentor = process_augmentations(config['augmentor'], global_rank=global_rank, world_size=world_size)
+    else:
+        augmentor = None
+
+    if 'hf_data_cfg' in config:
+        return get_hf_audio_to_text_bpe_dataset(
+            config=config, global_rank=global_rank, world_size=world_size, tokenizer=tokenizer, augmentor=augmentor
+        )
+
+    is_concat = config.get('is_concat', False)
+    if is_concat:
+        if 'concat_sampling_technique' in config and config['concat_sampling_technique'] is None:
+            logging.warning(
+                f"Concat dataset requires `concat_sampling_technique` but it was not provided. Config: {config}"
+            )
+            return None
+
+        if config['concat_sampling_technique'] == 'random':
+            if not 'concat_sampling_probabilities' in config:
+                logging.warning(f"Concat dataset requires `concat_sampling_probabilities` list. Config: {config}")
+                return None
+            else:
+                if not isclose(sum(config['concat_sampling_probabilities']), 1, abs_tol=1e-6):
+                    logging.warning(f"`concat_sampling_probabilities` need to sum to 1. Config: {config}")
+                    return None
+
+    shuffle = config['shuffle']
+    device = 'gpu' if torch.cuda.is_available() else 'cpu'
+    if config.get('use_dali', False):
+        device_id = local_rank if device == 'gpu' else None
+        dataset = get_dali_bpe_dataset(
+            config=config,
+            tokenizer=tokenizer,
+            shuffle=shuffle,
+            device_id=device_id,
+            global_rank=global_rank,
+            world_size=world_size,
+            preprocessor_cfg=preprocessor_cfg,
+        )
+        return dataset
+
+    # Instantiate a code-switched dataset if config is present
+    if config.get('is_code_switched', False):
+        if 'manifest_filepath' in config and config['manifest_filepath'] is None:
+            logging.warning(f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}")
+            return None
+        if not ('code_switched' in config and config['code_switched'] is not None):
+            logging.warning(
+                f"Code switched dataset requires `*_ds.code_switched.*` dict but it was not provided. Config: {config}"
+            )
+            return None
+        if (
+            ('probs' in config['code_switched'])
+            and (config['code_switched']['probs'] is not None)
+            and (not isclose(sum(config['code_switched']['probs']), 1, abs_tol=1e-6))
+        ):
+            logging.warning(f"`.code_switched.probs` need to sum to 1. Config: {config['code_switched']}")
+            return None
+
+        shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0
+        dataset = get_code_switched_dataset(
+            config=config,
+            shuffle_n=shuffle_n,
+            global_rank=global_rank,
+            world_size=world_size,
+            tokenizer=tokenizer,
+            augmentor=augmentor,
+        )
+    # Instantiate tarred dataset loader or normal dataset loader
+    elif config.get('is_tarred', False):
+        if ('tarred_audio_filepaths' in config and config['tarred_audio_filepaths'] is None) or (
+            'manifest_filepath' in config and config['manifest_filepath'] is None
+        ):
+            logging.warning(
+                "Could not load dataset as `manifest_filepath` was None or "
+                f"`tarred_audio_filepaths` is None. Provided config : {config}"
+            )
+            return None
+
+        shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0
+        if is_concat:
+            dataset = get_concat_tarred_dataset(
+                config=config,
+                tokenizer=tokenizer,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+            )
+        else:
+            dataset = get_tarred_dataset(
+                config=config,
+                tokenizer=tokenizer,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+            )
+    else:
+        if 'manifest_filepath' in config and config['manifest_filepath'] is None:
+            logging.warning(f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}")
+            return None
+        if is_concat:
+            dataset = get_concat_bpe_dataset(
+                config=config,
+                global_rank=global_rank,
+                world_size=world_size,
+                tokenizer=tokenizer,
+                augmentor=augmentor,
+            )
+        else:
+            dataset = get_bpe_dataset(config=config, tokenizer=tokenizer, augmentor=augmentor)
+    return dataset
+
+
+class ASRPredictionWriter(BasePredictionWriter):
+    def __init__(self, dataset, output_file: str):
+        super().__init__(write_interval="batch")
+        self.outf = open(output_file, 'w', encoding='utf-8')
+        self.dataset = dataset
+        self.samples_num = 0
+
+    def write_on_batch_end(
+        self,
+        trainer,
+        pl_module: 'LightningModule',
+        prediction: Any,
+        batch_indices: List[int],
+        batch: Any,
+        batch_idx: int,
+        dataloader_idx: int,
+    ):
+        import lhotse
+
+        for sample_id, transcribed_text in prediction:
+            item = {}
+            if isinstance(sample_id, lhotse.cut.Cut):
+                sample = sample_id
+                if isinstance(sample, lhotse.cut.MixedCut):
+                    sample = sample.first_non_padding_cut
+                if sample.recording.sources[0].source != '':
+                    item["audio_filepath"] = sample.recording.sources[0].source
+                else:
+                    item["audio_filepath"] = sample.id
+                item["offset"] = sample.start
+                item["duration"] = sample.duration
+                item["text"] = sample.supervisions[0].text or ''
+                if hasattr(sample, 'shard_id'):
+                    item["shard_id"] = sample.shard_id
+                item["pred_text"] = transcribed_text
+                self.outf.write(json.dumps(item) + "\n")
+                self.samples_num += 1
+            else:
+                sample = self.dataset.get_manifest_sample(sample_id)
+                item["audio_filepath"] = sample.audio_file
+                item["offset"] = sample.offset
+                item["duration"] = sample.duration
+                item["text"] = sample.text_raw
+                item["pred_text"] = transcribed_text
+                self.outf.write(json.dumps(item) + "\n")
+                self.samples_num += 1
+        return
+
+    def close_output_file(self):
+        self.outf.close()
+        return self.samples_num
+
+
+def convert_to_config_list(initial_list):
+    if type(initial_list) is str:
+        initial_list = initial_list.split(",")
+    if initial_list is None or initial_list == []:
+        raise ValueError("manifest_filepaths and tarred_audio_filepaths must not be empty.")
+    if not isinstance(initial_list, ListConfig):
+        initial_list = ListConfig([initial_list])
+
+    for list_idx, list_val in enumerate(initial_list):
+        if type(list_val) != type(initial_list[0]):
+            raise ValueError(
+                "manifest_filepaths and tarred_audio_filepaths need to be a list of lists for bucketing or just a list of strings"
+            )
+    if type(initial_list[0]) is not ListConfig:
+        initial_list = ListConfig([initial_list])
+    return initial_list
+
+
+def get_chain_dataset(datasets, ds_config, rank=0):
+    if len(datasets) > 1:
+        if ds_config.get('bucketing_batch_size', None) is not None:
+            bucketing_batch_sizes = calc_bucketing_batch_sizes(ds_config, len(datasets))
+            logging.info(
+                f"Batch bucketing is enabled for {len(datasets)} buckets with adaptive batch sizes of {bucketing_batch_sizes}!"
+            )
+            for idx, dataset in enumerate(datasets):
+                datasets[idx] = audio_to_text.BucketingDataset(
+                    dataset=dataset, bucketing_batch_size=bucketing_batch_sizes[idx]
+                )
+        else:
+            logging.info(
+                f"Batch bucketing is enabled for {len(datasets)} buckets with fixed batch size of {ds_config['batch_size']}!"
+            )
+
+    if len(datasets) == 1:
+        return datasets[0]
+    bucketing_strategy = ds_config.get('bucketing_strategy', 'synced_randomized')
+    if bucketing_strategy == 'fixed_order':
+        return ChainDataset(datasets)
+    elif bucketing_strategy == 'synced_randomized':
+        return audio_to_text.RandomizedChainDataset(datasets=datasets, rnd_seed=0)
+    elif bucketing_strategy == 'fully_randomized':
+        return audio_to_text.RandomizedChainDataset(datasets=datasets, rnd_seed=random.randint(0, 30000) + rank)
+    else:
+        raise ValueError(
+            f'bucketing_strategy={bucketing_strategy} is not supported! Supported strategies are [fixed_order, fully_randomized, synced_randomized].'
+        )
+
+
+def calc_bucketing_batch_sizes(ds_config, datasets_len):
+    bucketing_batch_size = ds_config['bucketing_batch_size']
+    bucketing_weights = ds_config.get('bucketing_weights', None)  # To adjust for upsampled buckets
+
+    bucketing_batch_sizes = []
+
+    if ds_config['batch_size'] != 1:
+        raise ValueError(
+            f"batch_size should be set to one when bucketing_batch_size is set and adaptive bucketing is enabled (batch_size={ds_config['batch_size']}!"
+        )
+    if type(bucketing_batch_size) == int:  # linear scaling
+        if bucketing_weights:  # Want same batchsize for the same duplicated bucket
+            for idx, weight in enumerate(bucketing_weights):
+                scale_factor = datasets_len - idx
+                [bucketing_batch_sizes.append(scale_factor * bucketing_batch_size) for _ in range(weight)]
+        else:
+            for idx in range(datasets_len):
+                scale_factor = datasets_len - idx
+                bucketing_batch_sizes.append(scale_factor * bucketing_batch_size)
+    elif isinstance(bucketing_batch_size, ListConfig) or isinstance(
+        bucketing_batch_size, list
+    ):  # assigned bucket sizes
+        if bucketing_weights:  # Want same batchsize for same duplicated bucket
+            for idx, weight in enumerate(bucketing_weights):
+                [bucketing_batch_sizes.append(bucketing_batch_size[idx]) for _ in range(weight)]
+        else:
+            bucketing_batch_sizes = bucketing_batch_size
+    else:
+        raise ValueError(
+            f"bucketing_batch_size should be an integer or a list (bucketing_batch_size={bucketing_batch_size})!"
+        )
+
+    if len(bucketing_batch_sizes) != datasets_len:
+        raise ValueError(
+            f"batch_size should have the same length as the number of buckets ({len(bucketing_batch_sizes)}!={datasets_len}) "
+        )
+    return bucketing_batch_sizes

nemo/collections/asr/data/audio_to_text_lhotse.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Dict, Optional, Tuple
+
+import torch.utils.data
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_vectors
+
+from nemo.collections.common.tokenizers.aggregate_tokenizer import TokenizerWrapper
+from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+
+
+class LhotseSpeechToTextBpeDataset(torch.utils.data.Dataset):
+    """
+    This dataset is based on BPE datasets from audio_to_text.py.
+    Unlike native NeMo datasets, Lhotse dataset defines only the mapping from
+    a CutSet (meta-data) to a mini-batch with PyTorch tensors.
+    Specifically, it performs tokenization, I/O, augmentation, and feature extraction (if any).
+    Managing data, sampling, de-duplication across workers/nodes etc. is all handled
+    by Lhotse samplers instead.
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(self, tokenizer: TokenizerSpec, return_cuts: bool = False):
+        super().__init__()
+        self.tokenizer = TokenizerWrapper(tokenizer)
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.return_cuts = return_cuts
+
+    def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
+        audio, audio_lens, cuts = self.load_audio(cuts)
+        tokens = [
+            torch.cat(
+                [
+                    torch.as_tensor(s.tokens if hasattr(s, "tokens") else self.tokenizer(s.text or "", s.language))
+                    for s in c.supervisions
+                ],
+                dim=0,
+            )
+            for c in cuts
+        ]
+        token_lens = torch.tensor([t.size(0) for t in tokens], dtype=torch.long)
+        tokens = collate_vectors(tokens, padding_value=0)
+        if self.return_cuts:
+            return audio, audio_lens, tokens, token_lens, cuts.drop_in_memory_data()
+        return audio, audio_lens, tokens, token_lens

nemo/collections/asr/data/audio_to_text_lhotse_prompted.py

@@ -0,0 +1,136 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+from dataclasses import dataclass
+from typing import Callable, Optional, Union
+
+import torch.utils.data
+from lhotse import CutSet
+from lhotse.cut import MixedCut
+from lhotse.dataset import AudioSamples
+from lhotse.dataset.collation import collate_vectors
+
+from nemo.collections.common.data import apply_prompt_format_fn
+from nemo.collections.common.prompts import CanaryPromptFormatter, PromptFormatter
+from nemo.collections.common.tokenizers import TokenizerSpec
+
+
+@dataclass
+class PromptedAudioToTextMiniBatch:
+    audio: torch.Tensor
+    audio_lens: torch.Tensor
+    transcript: torch.Tensor
+    transcript_lens: torch.Tensor
+    prompt: torch.Tensor
+    prompt_lens: torch.Tensor
+    prompted_transcript: torch.Tensor
+    prompted_transcript_lens: torch.Tensor
+    cuts: Optional[CutSet] = None
+
+    def get_decoder_inputs_outputs(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns the inputs and outputs of transformer decoder for training.
+        The input is ``prompted_transcript`` (minus last token),
+        and the output is ``prompted_transcript`` (minus first token).
+        """
+        return self.prompted_transcript[:, :-1], self.prompted_transcript[:, 1:]
+
+
+class PromptedAudioToTextLhotseDataset(torch.utils.data.Dataset):
+    """
+    This dataset is based on :class:`~nemo.collections.asr.data.audio_to_text_lhotse.LhotseSpeechToTextBpeDataset`.
+    It is a Lhotse-style dataset that converts a mini-batch of Cuts into tensors.
+    The main difference from ``LhotseSpeechToTextBpeDataset`` is that we introduce
+    a special prompt format for multitask encoder-decoder models.
+
+    To perform the prompt formatting, we accept a ``prompt_format_fn``.
+    It's expected to accept:
+    * a ``CutSet`` which it will internally iterate over for utterances, and
+    * a ``TokenizerWrapper`` object that will be internally used to tokenize the utterances
+
+    Tokenized utterances will be extended with special prompt tokens according to ``prompt_format_fn`` logic.
+    We support cuts with multiple supervision segments -- their tokenized texts will be concatenated before we add the prompt tokens.
+    This is useful, for example, in code-switched scenarios where each segment is spoken in a different language.
+    """
+
+    def __init__(
+        self,
+        tokenizer: TokenizerSpec,
+        prompt: PromptFormatter,
+    ):
+        super().__init__()
+        self.tokenizer = tokenizer
+        self.load_audio = AudioSamples(fault_tolerant=True)
+        self.padding_value = self.tokenizer.pad_id
+        self.prompt = prompt
+
+    def __getitem__(self, cuts: CutSet) -> PromptedAudioToTextMiniBatch:
+        audio, audio_lens, cuts = self.load_audio(cuts)
+
+        # Fast-path: the tokenization and prompt formatting was already done before sampling.
+        attrs = ("input_ids", "context_ids", "answer_ids")
+        pre_formatted = all(hasattr(c, a) for c in cuts for a in attrs)
+        if pre_formatted:
+            prompts_with_answers, prompts, answers = zip(*((c.input_ids, c.context_ids, c.answer_ids) for c in cuts))
+        else:
+            formatted = [apply_prompt_format_fn(cut, self.prompt) for cut in cuts]
+            prompts_with_answers = [ex["input_ids"] for ex in formatted]
+            prompts = [ex["context_ids"] for ex in formatted]
+            answers = [ex["answer_ids"] for ex in formatted]
+
+        transcript, transcript_lens = self._collate_tokens(answers)
+        prompts_with_answers, prompts_with_answers_lens = self._collate_tokens(prompts_with_answers)
+        prompts, prompt_lens = self._collate_tokens(prompts)
+
+        return PromptedAudioToTextMiniBatch(
+            audio=audio,
+            audio_lens=audio_lens,
+            transcript=transcript,
+            transcript_lens=transcript_lens,
+            prompt=prompts,
+            prompt_lens=prompt_lens,
+            prompted_transcript=prompts_with_answers,
+            prompted_transcript_lens=prompts_with_answers_lens,
+            cuts=_drop_in_memory_data(cuts),
+        )
+
+    def _collate_tokens(self, tokens: list[Union[list[int], torch.Tensor]]) -> tuple[torch.Tensor, torch.Tensor]:
+        tokens = [torch.as_tensor(t) for t in tokens]
+        token_lens = torch.tensor([t.size(0) for t in tokens], dtype=torch.long)
+        tokens = collate_vectors(tokens, padding_value=self.padding_value)
+        return tokens, token_lens
+
+
+class ProbablyIncorrectLanguageKeyError(RuntimeError):
+    pass
+
+
+def _drop_in_memory_data(
+    cuts: CutSet,
+    _fields=frozenset(MixedCut.__dataclass_fields__.keys()),
+) -> CutSet:
+    """Workaround for an edge case in cuts.drop_in_memory_data() on MixedCut with Lhotse<1.29.0"""
+    ans = []
+    for c in cuts:
+        # Not a mixed cut or a mixed cut that wasn't assigned any extra attributes.
+        if not isinstance(c, MixedCut) or _fields.issuperset(c.__dict__.keys()):
+            ans.append(c.drop_in_memory_data())
+        else:
+            extra_attrs = {k: v for k, v in c.__dict__.items() if k not in _fields}
+            for k in extra_attrs:
+                delattr(c, k)
+            ans.append(c.drop_in_memory_data())
+            for k, v in extra_attrs.items():
+                setattr(ans[-1], k, v)
+                setattr(c, k, v)
+    return CutSet(ans)

nemo/collections/asr/data/data_simulation.py

@@ -0,0 +1,1700 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 concurrent
+import os
+import warnings
+from typing import Dict, List, Tuple
+
+import numpy as np
+import soundfile as sf
+import torch
+from omegaconf import OmegaConf
+from scipy.signal import convolve
+from scipy.signal.windows import cosine, hamming, hann
+from tqdm import tqdm
+
+from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
+from nemo.collections.asr.parts.utils.data_simulation_utils import (
+    DataAnnotator,
+    SpeechSampler,
+    build_speaker_samples_map,
+    get_background_noise,
+    get_cleaned_base_path,
+    get_random_offset_index,
+    get_speaker_ids,
+    get_speaker_samples,
+    get_split_points_in_alignments,
+    load_speaker_sample,
+    normalize_audio,
+    per_speaker_normalize,
+    perturb_audio,
+    read_audio_from_buffer,
+    read_noise_manifest,
+)
+from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
+from nemo.collections.asr.parts.utils.speaker_utils import get_overlap_range, is_overlap, merge_float_intervals
+from nemo.utils import logging
+
+try:
+    import pyroomacoustics as pra
+    from pyroomacoustics.directivities import CardioidFamily, DirectionVector, DirectivityPattern
+
+    PRA = True
+except ImportError:
+    PRA = False
+try:
+    from gpuRIR import att2t_SabineEstimator, beta_SabineEstimation, simulateRIR, t2n
+
+    GPURIR = True
+except ImportError:
+    GPURIR = False
+
+
+class MultiSpeakerSimulator(object):
+    """
+    Multispeaker Audio Session Simulator - Simulates multispeaker audio sessions using single-speaker audio files and
+    corresponding word alignments.
+
+    Change Log:
+    v1.0: Dec 2022
+        - First working verison, supports multispeaker simulation with overlaps, silence and RIR
+        v1.0.1: Feb 2023
+            - Multi-GPU support for speed up
+            - Faster random sampling routine
+            - Fixed sentence duration bug
+            - Silence and overlap length sampling algorithms are updated to guarantee `mean_silence` approximation
+        v1.0.2: March 2023
+            - Added support for segment-level gain perturbation and session-level white-noise perturbation
+            - Modified speaker sampling mechanism to include as many speakers as possible in each data-generation run
+            - Added chunking mechanism to avoid freezing in multiprocessing processes
+
+    v1.1.0 March 2023
+        - Faster audio-file loading with maximum audio duration parameter
+        - Re-organized MultiSpeakerSimulator class and moved util functions to util files.
+        v1.1.1 March 2023
+            - Changed `silence_mean` to use exactly the same sampling equation as `overlap_mean`.
+
+
+    Args:
+        cfg: OmegaConf configuration loaded from yaml file.
+
+    Parameters:
+      manifest_filepath (str): Manifest file with paths to single speaker audio files
+      sr (int): Sampling rate of the input audio files from the manifest
+      random_seed (int): Seed to random number generator
+
+    session_config:
+      num_speakers (int): Number of unique speakers per multispeaker audio session
+      num_sessions (int): Number of sessions to simulate
+      session_length (int): Length of each simulated multispeaker audio session (seconds). Short sessions
+                            (e.g. ~240 seconds) tend to fall short of the expected overlap-ratio and silence-ratio.
+
+    session_params:
+      max_audio_read_sec (int): The maximum audio length in second when loading an audio file.
+                                The bigger the number, the slower the reading speed. Should be greater than 2.5 second.
+      sentence_length_params (list): k,p values for a negative_binomial distribution which is sampled to get the
+                                     sentence length (in number of words)
+      dominance_var (float): Variance in speaker dominance (where each speaker's dominance is sampled from a normal
+                             distribution centered on 1/`num_speakers`, and then the dominance values are together
+                             normalized to 1)
+      min_dominance (float): Minimum percentage of speaking time per speaker (note that this can cause the dominance of
+                             the other speakers to be slightly reduced)
+      turn_prob (float): Probability of switching speakers after each utterance
+
+      mean_silence (float): Mean proportion of silence to speaking time in the audio session. Should be in range [0, 1).
+      mean_silence_var (float): Variance for mean silence in all audio sessions.
+                                This value should be 0 <= mean_silence_var < mean_silence * (1 - mean_silence).
+      per_silence_var (float):  Variance for each silence in an audio session, set large values (e.g., 20) for de-correlation.
+      per_silence_min (float): Minimum duration for each silence, default to 0.
+      per_silence_max (float): Maximum duration for each silence, default to -1 for no maximum.
+      mean_overlap (float): Mean proportion of overlap in the overall non-silence duration. Should be in range [0, 1) and
+                            recommend [0, 0.15] range for accurate results.
+      mean_overlap_var (float): Variance for mean overlap in all audio sessions.
+                                This value should be 0 <= mean_overlap_var < mean_overlap * (1 - mean_overlap).
+      per_overlap_var (float): Variance for per overlap in each session, set large values to de-correlate silence lengths
+                               with the latest speech segment lengths
+      per_overlap_min (float): Minimum per overlap duration in seconds
+      per_overlap_max (float): Maximum per overlap duration in seconds, set -1 for no maximum
+      start_window (bool): Whether to window the start of sentences to smooth the audio signal (and remove silence at
+                            the start of the clip)
+      window_type (str): Type of windowing used when segmenting utterances ("hamming", "hann", "cosine")
+      window_size (float): Length of window at the start or the end of segmented utterance (seconds)
+      start_buffer (float): Buffer of silence before the start of the sentence (to avoid cutting off speech or starting
+                            abruptly)
+      split_buffer (float): Split RTTM labels if greater than twice this amount of silence (to avoid long gaps between
+                            utterances as being labelled as speech)
+      release_buffer (float): Buffer before window at end of sentence (to avoid cutting off speech or ending abruptly)
+      normalize (bool): Normalize speaker volumes
+      normalization_type (str): Normalizing speakers ("equal" - same volume per speaker, "var" - variable volume per
+                                speaker)
+      normalization_var (str): Variance in speaker volume (sample from standard deviation centered at 1)
+      min_volume (float): Minimum speaker volume (only used when variable normalization is used)
+      max_volume (float): Maximum speaker volume (only used when variable normalization is used)
+      end_buffer (float): Buffer at the end of the session to leave blank
+
+    outputs:
+      output_dir (str): Output directory for audio sessions and corresponding label files
+      output_filename (str): Output filename for the wav and RTTM files
+      overwrite_output (bool): If true, delete the output directory if it exists
+      output_precision (int): Number of decimal places in output files
+
+    background_noise:
+      add_bg (bool): Add ambient background noise if true
+      background_manifest (str): Path to background noise manifest file
+      snr (int): SNR for background noise (using average speaker power), set `snr_min` and `snr_max` values to enable random SNR
+      snr_min (int):  Min random SNR for background noise (using average speaker power), set `null` to use fixed SNR
+      snr_max (int):  Max random SNR for background noise (using average speaker power), set `null` to use fixed SNR
+
+    segment_augmentor:
+      add_seg_aug (bool): Set True to enable augmentation on each speech segment (Default: False)
+      segmentor:
+        gain:
+            prob (float): Probability range (uniform distribution) gain augmentation for individual segment
+            min_gain_dbfs (float): minimum gain in terms of dB
+            max_gain_dbfs (float): maximum gain in terms of dB
+
+    session_augmentor:
+      add_sess_aug: (bool) set True to enable audio augmentation on the whole session (Default: False)
+      segmentor:
+        white_noise:
+            prob (float): Probability of adding white noise (Default: 1.0)
+            min_level (float): minimum gain in terms of dB
+            max_level (float): maximum gain in terms of dB
+
+    speaker_enforcement:
+      enforce_num_speakers (bool): Enforce that all requested speakers are present in the output wav file
+      enforce_time (list): Percentage of the way through the audio session that enforcement mode is triggered (sampled
+                           between time 1 and 2)
+
+    segment_manifest: (parameters for regenerating the segment manifest file)
+      window (float): Window length for segmentation
+      shift (float): Shift length for segmentation
+      step_count (int): Number of the unit segments you want to create per utterance
+      deci (int): Rounding decimals for segment manifest file
+    """
+
+    def __init__(self, cfg):
+        self._params = cfg
+        self.annotator = DataAnnotator(cfg)
+        self.sampler = SpeechSampler(cfg)
+        # internal params
+        self._manifest = read_manifest(self._params.data_simulator.manifest_filepath)
+        self._speaker_samples = build_speaker_samples_map(self._manifest)
+        self._noise_samples = []
+        self._sentence = None
+        self._text = ""
+        self._words = []
+        self._alignments = []
+        # minimum number of alignments for a manifest to be considered valid
+        self._min_alignment_count = 2
+        self._merged_speech_intervals = []
+        # keep track of furthest sample per speaker to avoid overlapping same speaker
+        self._furthest_sample = [0 for n in range(self._params.data_simulator.session_config.num_speakers)]
+        # use to ensure overlap percentage is correct
+        self._missing_overlap = 0
+        # creating manifests during online data simulation
+        self.base_manifest_filepath = None
+        self.segment_manifest_filepath = None
+        self._max_audio_read_sec = self._params.data_simulator.session_params.max_audio_read_sec
+        self._turn_prob_min = self._params.data_simulator.session_params.get("turn_prob_min", 0.5)
+        # variable speaker volume
+        self._volume = None
+        self._speaker_ids = None
+        self._device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+        self._audio_read_buffer_dict = {}
+        self.add_missing_overlap = self._params.data_simulator.session_params.get("add_missing_overlap", False)
+
+        if (
+            self._params.data_simulator.segment_augmentor.get("augmentor", None)
+            and self._params.data_simulator.segment_augmentor.add_seg_aug
+        ):
+            self.segment_augmentor = process_augmentations(
+                augmenter=self._params.data_simulator.segment_augmentor.augmentor
+            )
+        else:
+            self.segment_augmentor = None
+
+        if (
+            self._params.data_simulator.session_augmentor.get("augmentor", None)
+            and self._params.data_simulator.session_augmentor.add_sess_aug
+        ):
+            self.session_augmentor = process_augmentations(
+                augmenter=self._params.data_simulator.session_augmentor.augmentor
+            )
+        else:
+            self.session_augmentor = None
+
+        # Error check the input arguments for simulation
+        self._check_args()
+
+        # Initialize speaker permutations to maximize the number of speakers in the created dataset
+        self._permutated_speaker_inds = self._init_speaker_permutations(
+            num_sess=self._params.data_simulator.session_config.num_sessions,
+            num_speakers=self._params.data_simulator.session_config.num_speakers,
+            all_speaker_ids=self._speaker_samples.keys(),
+            random_seed=self._params.data_simulator.random_seed,
+        )
+
+        # Intialize multiprocessing related variables
+        self.num_workers = self._params.get("num_workers", 1)
+        self.multiprocessing_chunksize = self._params.data_simulator.get('multiprocessing_chunksize', 10000)
+        self.chunk_count = self._init_chunk_count()
+
+    def _init_speaker_permutations(self, num_sess: int, num_speakers: int, all_speaker_ids: List, random_seed: int):
+        """
+        Initialize the speaker permutations for the number of speakers in the session.
+        When generating the simulated sessions, we want to include as many speakers as possible.
+        This function generates a set of permutations that can be used to sweep all speakers in
+        the source dataset to make sure we maximize the total number of speakers included in
+        the simulated sessions.
+
+        Args:
+            num_sess (int): Number of sessions to generate
+            num_speakers (int): Number of speakers in each session
+            all_speaker_ids (list): List of all speaker IDs
+
+        Returns:
+            permuted_inds (np.array):
+                Array of permuted speaker indices to use for each session
+                Dimensions: (num_sess, num_speakers)
+        """
+        np.random.seed(random_seed)
+        all_speaker_id_counts = len(list(all_speaker_ids))
+
+        # Calculate how many permutations are needed
+        perm_set_count = int(np.ceil(num_speakers * num_sess / all_speaker_id_counts))
+
+        target_count = num_speakers * num_sess
+        for count in range(perm_set_count):
+            if target_count < all_speaker_id_counts:
+                seq_len = target_count
+            else:
+                seq_len = all_speaker_id_counts
+            if seq_len <= 0:
+                raise ValueError(f"seq_len is {seq_len} at count {count} and should be greater than 0")
+
+            if count == 0:
+                permuted_inds = np.random.permutation(len(all_speaker_ids))[:seq_len]
+            else:
+                permuted_inds = np.hstack((permuted_inds, np.random.permutation(len(all_speaker_ids))[:seq_len]))
+            target_count -= seq_len
+
+        logging.info(f"Total {all_speaker_id_counts} speakers in the source dataset.")
+        logging.info(f"Initialized speaker permutations for {num_sess} sessions with {num_speakers} speakers each.")
+        return permuted_inds.reshape(num_sess, num_speakers)
+
+    def _init_chunk_count(self):
+        """
+        Initialize the chunk count for multi-processing to prevent over-flow of job counts.
+        The multi-processing pipeline can freeze if there are more than approximately 10,000 jobs
+        in the pipeline at the same time.
+        """
+        return int(np.ceil(self._params.data_simulator.session_config.num_sessions / self.multiprocessing_chunksize))
+
+    def _check_args(self):
+        """
+        Checks YAML arguments to ensure they are within valid ranges.
+        """
+        if self._params.data_simulator.session_config.num_speakers < 1:
+            raise Exception("At least one speaker is required for making audio sessions (num_speakers < 1)")
+        if (
+            self._params.data_simulator.session_params.turn_prob < 0
+            or self._params.data_simulator.session_params.turn_prob > 1
+        ):
+            raise Exception("Turn probability is outside of [0,1]")
+        if (
+            self._params.data_simulator.session_params.turn_prob < 0
+            or self._params.data_simulator.session_params.turn_prob > 1
+        ):
+            raise Exception("Turn probability is outside of [0,1]")
+        elif (
+            self._params.data_simulator.session_params.turn_prob < self._turn_prob_min
+            and self._params.data_simulator.speaker_enforcement.enforce_num_speakers == True
+        ):
+            logging.warning(
+                "Turn probability is less than {self._turn_prob_min} while enforce_num_speakers=True, which may result in excessive session lengths. Forcing turn_prob to 0.5."
+            )
+            self._params.data_simulator.session_params.turn_prob = self._turn_prob_min
+        if self._params.data_simulator.session_params.max_audio_read_sec < 2.5:
+            raise Exception("Max audio read time must be greater than 2.5 seconds")
+
+        if self._params.data_simulator.session_params.sentence_length_params[0] <= 0:
+            raise Exception(
+                "k (number of success until the exp. ends) in Sentence length parameter value must be a positive number"
+            )
+
+        if not (0 < self._params.data_simulator.session_params.sentence_length_params[1] <= 1):
+            raise Exception("p (success probability) value in sentence length parameter must be in range (0,1]")
+
+        if (
+            self._params.data_simulator.session_params.mean_overlap < 0
+            or self._params.data_simulator.session_params.mean_overlap > 1
+        ):
+            raise Exception("Mean overlap is outside of [0,1]")
+        if (
+            self._params.data_simulator.session_params.mean_silence < 0
+            or self._params.data_simulator.session_params.mean_silence > 1
+        ):
+            raise Exception("Mean silence is outside of [0,1]")
+        if self._params.data_simulator.session_params.mean_silence_var < 0:
+            raise Exception("Mean silence variance is not below 0")
+        if (
+            self._params.data_simulator.session_params.mean_silence > 0
+            and self._params.data_simulator.session_params.mean_silence_var
+            >= self._params.data_simulator.session_params.mean_silence
+            * (1 - self._params.data_simulator.session_params.mean_silence)
+        ):
+            raise Exception("Mean silence variance should be lower than mean_silence * (1-mean_silence)")
+        if self._params.data_simulator.session_params.per_silence_var < 0:
+            raise Exception("Per silence variance is below 0")
+
+        if self._params.data_simulator.session_params.mean_overlap_var < 0:
+            raise Exception("Mean overlap variance is not larger than 0")
+        if (
+            self._params.data_simulator.session_params.mean_overlap > 0
+            and self._params.data_simulator.session_params.mean_overlap_var
+            >= self._params.data_simulator.session_params.mean_overlap
+            * (1 - self._params.data_simulator.session_params.mean_overlap)
+        ):
+            raise Exception("Mean overlap variance should be lower than mean_overlap * (1-mean_overlap)")
+        if self._params.data_simulator.session_params.per_overlap_var < 0:
+            raise Exception("Per overlap variance is not larger than 0")
+
+        if (
+            self._params.data_simulator.session_params.min_dominance < 0
+            or self._params.data_simulator.session_params.min_dominance > 1
+        ):
+            raise Exception("Minimum dominance is outside of [0,1]")
+        if (
+            self._params.data_simulator.speaker_enforcement.enforce_time[0] < 0
+            or self._params.data_simulator.speaker_enforcement.enforce_time[0] > 1
+        ):
+            raise Exception("Speaker enforcement start is outside of [0,1]")
+        if (
+            self._params.data_simulator.speaker_enforcement.enforce_time[1] < 0
+            or self._params.data_simulator.speaker_enforcement.enforce_time[1] > 1
+        ):
+            raise Exception("Speaker enforcement end is outside of [0,1]")
+
+        if (
+            self._params.data_simulator.session_params.min_dominance
+            * self._params.data_simulator.session_config.num_speakers
+            > 1
+        ):
+            raise Exception("Number of speakers times minimum dominance is greater than 1")
+
+        if (
+            self._params.data_simulator.session_params.window_type not in ['hamming', 'hann', 'cosine']
+            and self._params.data_simulator.session_params.window_type is not None
+        ):
+            raise Exception("Incorrect window type provided")
+
+        if len(self._manifest) == 0:
+            raise Exception("Manifest file is empty. Check that the source path is correct.")
+
+    def clean_up(self):
+        """
+        Clear the system memory. Cache data for audio files and alignments are removed.
+        """
+        self._sentence = None
+        self._words = []
+        self._alignments = []
+        self._audio_read_buffer_dict = {}
+        torch.cuda.empty_cache()
+
+    def _get_speaker_dominance(self) -> List[float]:
+        """
+        Get the dominance value for each speaker, accounting for the dominance variance and
+        the minimum per-speaker dominance.
+
+        Returns:
+            dominance (list): Per-speaker dominance
+        """
+        dominance_mean = 1.0 / self._params.data_simulator.session_config.num_speakers
+        dominance = np.random.normal(
+            loc=dominance_mean,
+            scale=self._params.data_simulator.session_params.dominance_var,
+            size=self._params.data_simulator.session_config.num_speakers,
+        )
+        dominance = np.clip(dominance, a_min=0, a_max=np.inf)
+        # normalize while maintaining minimum dominance
+        total = np.sum(dominance)
+        if total == 0:
+            for i in range(len(dominance)):
+                dominance[i] += self._params.data_simulator.session_params.min_dominance
+        # scale accounting for min_dominance which has to be added after
+        dominance = (dominance / total) * (
+            1
+            - self._params.data_simulator.session_params.min_dominance
+            * self._params.data_simulator.session_config.num_speakers
+        )
+        for i in range(len(dominance)):
+            dominance[i] += self._params.data_simulator.session_params.min_dominance
+            if (
+                i > 0
+            ):  # dominance values are cumulative to make it easy to select the speaker using a random value in [0,1]
+                dominance[i] = dominance[i] + dominance[i - 1]
+        return dominance
+
+    def _increase_speaker_dominance(
+        self, base_speaker_dominance: List[float], factor: int
+    ) -> Tuple[List[float], bool]:
+        """
+        Increase speaker dominance for unrepresented speakers (used only in enforce mode).
+        Increases the dominance for these speakers by the input factor (and then re-normalizes the probabilities to 1).
+
+        Args:
+            base_speaker_dominance (list): Dominance values for each speaker.
+            factor (int): Factor to increase dominance of unrepresented speakers by.
+        Returns:
+            dominance (list): Per-speaker dominance
+            enforce (bool): Whether to keep enforce mode turned on
+        """
+        increase_percent = []
+        for i in range(self._params.data_simulator.session_config.num_speakers):
+            if self._furthest_sample[i] == 0:
+                increase_percent.append(i)
+        # ramp up enforce counter until speaker is sampled, then reset once all speakers have spoken
+        if len(increase_percent) > 0:
+            # extract original per-speaker probabilities
+            dominance = np.copy(base_speaker_dominance)
+            for i in range(len(dominance) - 1, 0, -1):
+                dominance[i] = dominance[i] - dominance[i - 1]
+            # increase specified speakers by the desired factor
+            for i in increase_percent:
+                dominance[i] = dominance[i] * factor
+            # renormalize
+            dominance = dominance / np.sum(dominance)
+            for i in range(1, len(dominance)):
+                dominance[i] = dominance[i] + dominance[i - 1]
+            enforce = True
+        else:  # no unrepresented speakers, so enforce mode can be turned off
+            dominance = base_speaker_dominance
+            enforce = False
+        return dominance, enforce
+
+    def _set_speaker_volume(self):
+        """
+        Set the volume for each speaker (either equal volume or variable speaker volume).
+        """
+        if self._params.data_simulator.session_params.normalization_type == 'equal':
+            self._volume = np.ones(self._params.data_simulator.session_config.num_speakers)
+        elif self._params.data_simulator.session_params.normalization_type == 'variable':
+            self._volume = np.random.normal(
+                loc=1.0,
+                scale=self._params.data_simulator.session_params.normalization_var,
+                size=self._params.data_simulator.session_config.num_speakers,
+            )
+            self._volume = np.clip(
+                np.array(self._volume),
+                a_min=self._params.data_simulator.session_params.min_volume,
+                a_max=self._params.data_simulator.session_params.max_volume,
+            ).tolist()
+
+    def _get_next_speaker(self, prev_speaker: int, dominance: List[float]) -> int:
+        """
+        Get the next speaker (accounting for turn probability and dominance distribution).
+
+        Args:
+            prev_speaker (int): Previous speaker turn.
+            dominance (list): Dominance values for each speaker.
+        Returns:
+            prev_speaker/speaker_turn (int): Speaker turn
+        """
+        if self._params.data_simulator.session_config.num_speakers == 1:
+            prev_speaker = 0 if prev_speaker is None else prev_speaker
+            return prev_speaker
+        else:
+            if (
+                np.random.uniform(0, 1) > self._params.data_simulator.session_params.turn_prob
+                and prev_speaker is not None
+            ):
+                return prev_speaker
+            else:
+                speaker_turn = prev_speaker
+                while speaker_turn == prev_speaker:  # ensure another speaker goes next
+                    rand = np.random.uniform(0, 1)
+                    speaker_turn = 0
+                    while rand > dominance[speaker_turn]:
+                        speaker_turn += 1
+                return speaker_turn
+
+    def _get_window(self, window_amount: int, start: bool = False):
+        """
+        Get window curve to alleviate abrupt change of time-series signal when segmenting audio samples.
+
+        Args:
+            window_amount (int): Window length (in terms of number of samples).
+            start (bool): If true, return the first half of the window.
+
+        Returns:
+            window (tensor): Half window (either first half or second half)
+        """
+        if self._params.data_simulator.session_params.window_type == 'hamming':
+            window = hamming(window_amount * 2)
+        elif self._params.data_simulator.session_params.window_type == 'hann':
+            window = hann(window_amount * 2)
+        elif self._params.data_simulator.session_params.window_type == 'cosine':
+            window = cosine(window_amount * 2)
+        else:
+            raise Exception("Incorrect window type provided")
+
+        window = torch.from_numpy(window).to(self._device)
+
+        # return the first half or second half of the window
+        if start:
+            return window[:window_amount]
+        else:
+            return window[window_amount:]
+
+    def _get_start_buffer_and_window(self, first_alignment: int) -> Tuple[int, int]:
+        """
+        Get the start cutoff and window length for smoothing the start of the sentence.
+
+        Args:
+            first_alignment (int): Start of the first word (in terms of number of samples).
+        Returns:
+            start_cutoff (int): Amount into the audio clip to start
+            window_amount (int): Window length
+        """
+        window_amount = int(self._params.data_simulator.session_params.window_size * self._params.data_simulator.sr)
+        start_buffer = int(self._params.data_simulator.session_params.start_buffer * self._params.data_simulator.sr)
+
+        if first_alignment < start_buffer:
+            window_amount = 0
+            start_cutoff = 0
+        elif first_alignment < start_buffer + window_amount:
+            window_amount = first_alignment - start_buffer
+            start_cutoff = 0
+        else:
+            start_cutoff = first_alignment - start_buffer - window_amount
+
+        return start_cutoff, window_amount
+
+    def _get_end_buffer_and_window(
+        self, current_sample_cursor: int, remaining_dur_samples: int, remaining_len_audio_file: int
+    ) -> Tuple[int, int]:
+        """
+        Get the end buffer and window length for smoothing the end of the sentence.
+
+        Args:
+            current_sample_cursor (int): Current location in the target file (in terms of number of samples).
+            remaining_dur_samples (int): Remaining duration in the target file (in terms of number of samples).
+            remaining_len_audio_file (int): Length remaining in audio file (in terms of number of samples).
+        Returns:
+            release_buffer (int): Amount after the end of the last alignment to include
+            window_amount (int): Window length
+        """
+        window_amount = int(self._params.data_simulator.session_params.window_size * self._params.data_simulator.sr)
+        release_buffer = int(
+            self._params.data_simulator.session_params.release_buffer * self._params.data_simulator.sr
+        )
+
+        if current_sample_cursor + release_buffer > remaining_dur_samples:
+            release_buffer = remaining_dur_samples - current_sample_cursor
+            window_amount = 0
+        elif current_sample_cursor + window_amount + release_buffer > remaining_dur_samples:
+            window_amount = remaining_dur_samples - current_sample_cursor - release_buffer
+
+        if remaining_len_audio_file < release_buffer:
+            release_buffer = remaining_len_audio_file
+            window_amount = 0
+        elif remaining_len_audio_file < release_buffer + window_amount:
+            window_amount = remaining_len_audio_file - release_buffer
+
+        return release_buffer, window_amount
+
+    def _check_missing_speakers(self, num_missing: int = 0):
+        """
+        Check if any speakers were not included in the clip and display a warning.
+
+        Args:
+            num_missing (int): Number of missing speakers.
+        """
+        for k in range(len(self._furthest_sample)):
+            if self._furthest_sample[k] == 0:
+                num_missing += 1
+        if num_missing != 0:
+            warnings.warn(
+                f"{self._params.data_simulator.session_config.num_speakers - num_missing}"
+                f"speakers were included in the clip instead of the requested amount of "
+                f"{self._params.data_simulator.session_config.num_speakers}"
+            )
+
+    def _add_file(
+        self,
+        audio_manifest: dict,
+        audio_file,
+        sentence_word_count: int,
+        max_word_count_in_sentence: int,
+        max_samples_in_sentence: int,
+        random_offset: bool = False,
+    ) -> Tuple[int, torch.Tensor]:
+        """
+        Add audio file to current sentence (up to the desired number of words).
+        Uses the alignments to segment the audio file.
+        NOTE: 0 index is always silence in `audio_manifest['words']`, so we choose `offset_idx=1` as the first word
+
+        Args:
+            audio_manifest (dict): Line from manifest file for current audio file
+            audio_file (tensor): Current loaded audio file
+            sentence_word_count (int): Running count for number of words in sentence
+            max_word_count_in_sentence (int): Maximum count for number of words in sentence
+            max_samples_in_sentence (int): Maximum length for sentence in terms of samples
+
+        Returns:
+            sentence_word_count+current_word_count (int): Running word count
+            len(self._sentence) (tensor): Current length of the audio file
+        """
+        # In general, random offset is not needed since random silence index has already been chosen
+        if random_offset:
+            offset_idx = np.random.randint(low=1, high=len(audio_manifest['words']))
+        else:
+            offset_idx = 1
+
+        first_alignment = int(audio_manifest['alignments'][offset_idx - 1] * self._params.data_simulator.sr)
+        start_cutoff, start_window_amount = self._get_start_buffer_and_window(first_alignment)
+        if not self._params.data_simulator.session_params.start_window:  # cut off the start of the sentence
+            start_window_amount = 0
+
+        # Ensure the desired number of words are added and the length of the output session isn't exceeded
+        sentence_samples = len(self._sentence)
+
+        remaining_dur_samples = max_samples_in_sentence - sentence_samples
+        remaining_duration = max_word_count_in_sentence - sentence_word_count
+        prev_dur_samples, dur_samples, curr_dur_samples = 0, 0, 0
+        current_word_count = 0
+        word_idx = offset_idx
+        silence_count = 1
+        while (
+            current_word_count < remaining_duration
+            and dur_samples < remaining_dur_samples
+            and word_idx < len(audio_manifest['words'])
+        ):
+            dur_samples = int(audio_manifest['alignments'][word_idx] * self._params.data_simulator.sr) - start_cutoff
+
+            # check the length of the generated sentence in terms of sample count (int).
+            if curr_dur_samples + dur_samples > remaining_dur_samples:
+                # if the upcoming loop will exceed the remaining sample count, break out of the loop.
+                break
+
+            word = audio_manifest['words'][word_idx]
+
+            if silence_count > 0 and word == "":
+                break
+
+            self._words.append(word)
+            self._alignments.append(
+                float(sentence_samples * 1.0 / self._params.data_simulator.sr)
+                - float(start_cutoff * 1.0 / self._params.data_simulator.sr)
+                + audio_manifest['alignments'][word_idx]
+            )
+
+            if word == "":
+                word_idx += 1
+                silence_count += 1
+                continue
+            elif self._text == "":
+                self._text += word
+            else:
+                self._text += " " + word
+
+            word_idx += 1
+            current_word_count += 1
+            prev_dur_samples = dur_samples
+            curr_dur_samples += dur_samples
+
+        # add audio clip up to the final alignment
+        if self._params.data_simulator.session_params.window_type is not None:  # cut off the start of the sentence
+            if start_window_amount > 0:  # include window
+                window = self._get_window(start_window_amount, start=True)
+                self._sentence = self._sentence.to(self._device)
+                self._sentence = torch.cat(
+                    (
+                        self._sentence,
+                        torch.multiply(audio_file[start_cutoff : start_cutoff + start_window_amount], window),
+                    ),
+                    0,
+                )
+            self._sentence = torch.cat(
+                (
+                    self._sentence,
+                    audio_file[start_cutoff + start_window_amount : start_cutoff + prev_dur_samples],
+                ),
+                0,
+            ).to(self._device)
+
+        else:
+            self._sentence = torch.cat(
+                (self._sentence, audio_file[start_cutoff : start_cutoff + prev_dur_samples]), 0
+            ).to(self._device)
+
+        # windowing at the end of the sentence
+        if (
+            word_idx < len(audio_manifest['words'])
+        ) and self._params.data_simulator.session_params.window_type is not None:
+            release_buffer, end_window_amount = self._get_end_buffer_and_window(
+                prev_dur_samples,
+                remaining_dur_samples,
+                len(audio_file[start_cutoff + prev_dur_samples :]),
+            )
+            self._sentence = torch.cat(
+                (
+                    self._sentence,
+                    audio_file[start_cutoff + prev_dur_samples : start_cutoff + prev_dur_samples + release_buffer],
+                ),
+                0,
+            ).to(self._device)
+
+            if end_window_amount > 0:  # include window
+                window = self._get_window(end_window_amount, start=False)
+                sig_start = start_cutoff + prev_dur_samples + release_buffer
+                sig_end = start_cutoff + prev_dur_samples + release_buffer + end_window_amount
+                windowed_audio_file = torch.multiply(audio_file[sig_start:sig_end], window)
+                self._sentence = torch.cat((self._sentence, windowed_audio_file), 0).to(self._device)
+
+        del audio_file
+        return sentence_word_count + current_word_count, len(self._sentence)
+
+    def _build_sentence(
+        self,
+        speaker_turn: int,
+        speaker_ids: List[str],
+        speaker_wav_align_map: Dict[str, list],
+        max_samples_in_sentence: int,
+    ):
+        """
+        Build a new sentence by attaching utterance samples together until the sentence has reached a desired length.
+        While generating the sentence, alignment information is used to segment the audio.
+
+        Args:
+            speaker_turn (int): Current speaker turn.
+            speaker_ids (list): LibriSpeech speaker IDs for each speaker in the current session.
+            speaker_wav_align_map (dict): Dictionary containing speaker IDs and their corresponding wav filepath and alignments.
+            max_samples_in_sentence (int): Maximum length for sentence in terms of samples
+        """
+        # select speaker length
+        sl = (
+            np.random.negative_binomial(
+                self._params.data_simulator.session_params.sentence_length_params[0],
+                self._params.data_simulator.session_params.sentence_length_params[1],
+            )
+            + 1
+        )
+
+        # initialize sentence, text, words, alignments
+        self._sentence = torch.zeros(0, dtype=torch.float64, device=self._device)
+        self._text = ""
+        self._words, self._alignments = [], []
+        sentence_word_count, sentence_samples = 0, 0
+
+        # build sentence
+        while sentence_word_count < sl and sentence_samples < max_samples_in_sentence:
+            audio_manifest = load_speaker_sample(
+                speaker_wav_align_map=speaker_wav_align_map,
+                speaker_ids=speaker_ids,
+                speaker_turn=speaker_turn,
+                min_alignment_count=self._min_alignment_count,
+            )
+
+            offset_index = get_random_offset_index(
+                audio_manifest=audio_manifest,
+                audio_read_buffer_dict=self._audio_read_buffer_dict,
+                offset_min=0,
+                max_audio_read_sec=self._max_audio_read_sec,
+                min_alignment_count=self._min_alignment_count,
+            )
+
+            audio_file, sr, audio_manifest = read_audio_from_buffer(
+                audio_manifest=audio_manifest,
+                buffer_dict=self._audio_read_buffer_dict,
+                offset_index=offset_index,
+                device=self._device,
+                max_audio_read_sec=self._max_audio_read_sec,
+                min_alignment_count=self._min_alignment_count,
+                read_subset=True,
+            )
+
+            # Step 6-2: Add optional perturbations to the specific audio segment (i.e. to `self._sentnece`)
+            if self._params.data_simulator.segment_augmentor.add_seg_aug:
+                audio_file = perturb_audio(audio_file, sr, self.segment_augmentor, device=self._device)
+
+            sentence_word_count, sentence_samples = self._add_file(
+                audio_manifest, audio_file, sentence_word_count, sl, max_samples_in_sentence
+            )
+
+        # per-speaker normalization (accounting for active speaker time)
+        if self._params.data_simulator.session_params.normalize and torch.max(torch.abs(self._sentence)) > 0:
+            splits = get_split_points_in_alignments(
+                words=self._words,
+                alignments=self._alignments,
+                split_buffer=self._params.data_simulator.session_params.split_buffer,
+                sr=self._params.data_simulator.sr,
+                sentence_audio_len=len(self._sentence),
+            )
+            self._sentence = per_speaker_normalize(
+                sentence_audio=self._sentence,
+                splits=splits,
+                speaker_turn=speaker_turn,
+                volume=self._volume,
+                device=self._device,
+            )
+
+    def _add_silence_or_overlap(
+        self,
+        speaker_turn: int,
+        prev_speaker: int,
+        start: int,
+        length: int,
+        session_len_samples: int,
+        prev_len_samples: int,
+        enforce: bool,
+    ) -> int:
+        """
+        Returns new overlapped (or shifted) start position after inserting overlap or silence.
+
+        Args:
+            speaker_turn (int): The integer index of the current speaker turn.
+            prev_speaker (int): The integer index of the previous speaker turn.
+            start (int): Current start of the audio file being inserted.
+            length (int): Length of the audio file being inserted.
+            session_len_samples (int): Maximum length of the session in terms of number of samples
+            prev_len_samples (int): Length of previous sentence (in terms of number of samples)
+            enforce (bool): Whether speaker enforcement mode is being used
+        Returns:
+            new_start (int): New starting position in the session accounting for overlap or silence
+        """
+        running_len_samples = start + length
+        # `length` is the length of the current sentence to be added, so not included in self.sampler.running_speech_len_samples
+        non_silence_len_samples = self.sampler.running_speech_len_samples + length
+
+        # compare silence and overlap ratios
+        add_overlap = self.sampler.silence_vs_overlap_selector(running_len_samples, non_silence_len_samples)
+
+        # choose overlap if this speaker is not the same as the previous speaker and add_overlap is True.
+        if prev_speaker != speaker_turn and prev_speaker is not None and add_overlap:
+            desired_overlap_amount = self.sampler.sample_from_overlap_model(non_silence_len_samples)
+            new_start = start - desired_overlap_amount
+
+            # avoid overlap at start of clip
+            if new_start < 0:
+                desired_overlap_amount -= 0 - new_start
+                self._missing_overlap += 0 - new_start
+                new_start = 0
+
+            # if same speaker ends up overlapping from any previous clip, pad with silence instead
+            if new_start < self._furthest_sample[speaker_turn]:
+                desired_overlap_amount -= self._furthest_sample[speaker_turn] - new_start
+                self._missing_overlap += self._furthest_sample[speaker_turn] - new_start
+                new_start = self._furthest_sample[speaker_turn]
+
+            prev_start = start - prev_len_samples
+            prev_end = start
+            new_end = new_start + length
+
+            # check overlap amount to calculate the actual amount of generated overlaps
+            overlap_amount = 0
+            if is_overlap([prev_start, prev_end], [new_start, new_end]):
+                overlap_range = get_overlap_range([prev_start, prev_end], [new_start, new_end])
+                overlap_amount = max(overlap_range[1] - overlap_range[0], 0)
+
+            if overlap_amount < desired_overlap_amount:
+                self._missing_overlap += desired_overlap_amount - overlap_amount
+            self.sampler.running_overlap_len_samples += overlap_amount
+
+        # if we are not adding overlap, add silence
+        else:
+            silence_amount = self.sampler.sample_from_silence_model(running_len_samples)
+            if start + length + silence_amount > session_len_samples and not enforce:
+                new_start = max(session_len_samples - length, start)
+            else:
+                new_start = start + silence_amount
+        return new_start
+
+    def _get_session_meta_data(self, array: np.ndarray, snr: float) -> dict:
+        """
+        Get meta data for the current session.
+
+        Args:
+            array (np.ndarray): audio array
+            snr (float): signal-to-noise ratio
+
+        Returns:
+            dict: meta data
+        """
+        meta_data = {
+            "duration": array.shape[0] / self._params.data_simulator.sr,
+            "silence_mean": self.sampler.sess_silence_mean,
+            "overlap_mean": self.sampler.sess_overlap_mean,
+            "bg_snr": snr,
+            "speaker_ids": self._speaker_ids,
+            "speaker_volumes": list(self._volume),
+        }
+        return meta_data
+
+    def _get_session_silence_from_rttm(self, rttm_list: List[str], running_len_samples: int):
+        """
+        Calculate the total speech and silence duration in the current session using RTTM file.
+
+        Args:
+            rttm_list (list):
+                List of RTTM timestamps
+            running_len_samples (int):
+                Total number of samples generated so far in the current session
+
+        Returns:
+            sess_speech_len_rttm (int):
+                The total number of speech samples in the current session
+            sess_silence_len_rttm (int):
+                The total number of silence samples in the current session
+        """
+        all_sample_list = []
+        for x_raw in rttm_list:
+            x = [token for token in x_raw.split()]
+            all_sample_list.append([float(x[0]), float(x[1])])
+
+        self._merged_speech_intervals = merge_float_intervals(all_sample_list)
+        total_speech_in_secs = sum([x[1] - x[0] for x in self._merged_speech_intervals])
+        total_silence_in_secs = running_len_samples / self._params.data_simulator.sr - total_speech_in_secs
+        sess_speech_len = int(total_speech_in_secs * self._params.data_simulator.sr)
+        sess_silence_len = int(total_silence_in_secs * self._params.data_simulator.sr)
+        return sess_speech_len, sess_silence_len
+
+    def _add_sentence_to_array(
+        self, start: int, length: int, array: torch.Tensor, is_speech: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor, int]:
+        """
+        Add a sentence to the session array containing time-series signal.
+
+        Args:
+            start (int): Starting position in the session
+            length (int): Length of the sentence
+            array (torch.Tensor): Session array
+            is_speech (torch.Tensor): Session array containing speech/non-speech labels
+
+        Returns:
+            array (torch.Tensor): Session array in torch.Tensor format
+            is_speech (torch.Tensor): Session array containing speech/non-speech labels in torch.Tensor format
+        """
+        end = start + length
+        if end > len(array):  # only occurs in enforce mode
+            array = torch.nn.functional.pad(array, (0, end - len(array)))
+            is_speech = torch.nn.functional.pad(is_speech, (0, end - len(is_speech)))
+        array[start:end] += self._sentence
+        is_speech[start:end] = 1
+        return array, is_speech, end
+
+    def _generate_session(
+        self,
+        idx: int,
+        basepath: str,
+        filename: str,
+        speaker_ids: List[str],
+        speaker_wav_align_map: Dict[str, list],
+        noise_samples: list,
+        device: torch.device,
+        enforce_counter: int = 2,
+    ):
+        """
+        _generate_session function without RIR simulation.
+        Generate a multispeaker audio session and corresponding label files.
+
+        Args:
+            idx (int): Index for current session (out of total number of sessions).
+            basepath (str): Path to output directory.
+            filename (str): Filename for output files.
+            speaker_ids (list): List of speaker IDs that will be used in this session.
+            speaker_wav_align_map (dict): Dictionary containing speaker IDs and their corresponding wav filepath and alignments.
+            noise_samples (list): List of randomly sampled noise source files that will be used for generating this session.
+            device (torch.device): Device to use for generating this session.
+            enforce_counter (int): In enforcement mode, dominance is increased by a factor of enforce_counter for unrepresented speakers
+        """
+        random_seed = self._params.data_simulator.random_seed
+        np.random.seed(random_seed + idx)
+
+        self._device = device
+        speaker_dominance = self._get_speaker_dominance()  # randomly determine speaker dominance
+        base_speaker_dominance = np.copy(speaker_dominance)
+        self._set_speaker_volume()
+
+        running_len_samples, prev_len_samples = 0, 0
+        prev_speaker = None
+        self.annotator.init_annotation_lists()
+        self._noise_samples = noise_samples
+        self._furthest_sample = [0 for n in range(self._params.data_simulator.session_config.num_speakers)]
+        self._missing_silence = 0
+
+        # hold enforce until all speakers have spoken
+        enforce_time = np.random.uniform(
+            self._params.data_simulator.speaker_enforcement.enforce_time[0],
+            self._params.data_simulator.speaker_enforcement.enforce_time[1],
+        )
+        enforce = self._params.data_simulator.speaker_enforcement.enforce_num_speakers
+
+        session_len_samples = int(
+            (self._params.data_simulator.session_config.session_length * self._params.data_simulator.sr)
+        )
+        array = torch.zeros(session_len_samples).to(self._device)
+        is_speech = torch.zeros(session_len_samples).to(self._device)
+
+        self.sampler.get_session_silence_mean()
+        self.sampler.get_session_overlap_mean()
+
+        while running_len_samples < session_len_samples or enforce:
+            # Step 1: Prepare parameters for sentence generation
+            # Enforce speakers depending on running length
+            if running_len_samples > enforce_time * session_len_samples and enforce:
+                speaker_dominance, enforce = self._increase_speaker_dominance(base_speaker_dominance, enforce_counter)
+                if enforce:
+                    enforce_counter += 1
+
+            # Step 2: Select a speaker
+            speaker_turn = self._get_next_speaker(prev_speaker, speaker_dominance)
+
+            # Calculate parameters for building a sentence (only add if remaining length >  specific time)
+            max_samples_in_sentence = session_len_samples - running_len_samples
+            if enforce:
+                max_samples_in_sentence = float('inf')
+            elif (
+                max_samples_in_sentence
+                < self._params.data_simulator.session_params.end_buffer * self._params.data_simulator.sr
+            ):
+                break
+
+            # Step 3: Generate a sentence
+            self._build_sentence(speaker_turn, speaker_ids, speaker_wav_align_map, max_samples_in_sentence)
+            length = len(self._sentence)
+
+            # Step 4: Generate a timestamp for either silence or overlap
+            start = self._add_silence_or_overlap(
+                speaker_turn=speaker_turn,
+                prev_speaker=prev_speaker,
+                start=running_len_samples,
+                length=length,
+                session_len_samples=session_len_samples,
+                prev_len_samples=prev_len_samples,
+                enforce=enforce,
+            )
+            # step 5: add sentence to array
+            array, is_speech, end = self._add_sentence_to_array(
+                start=start,
+                length=length,
+                array=array,
+                is_speech=is_speech,
+            )
+
+            # Step 6: Build entries for output files
+            new_rttm_entries = self.annotator.create_new_rttm_entry(
+                words=self._words,
+                alignments=self._alignments,
+                start=start / self._params.data_simulator.sr,
+                end=end / self._params.data_simulator.sr,
+                speaker_id=speaker_ids[speaker_turn],
+            )
+
+            self.annotator.annote_lists['rttm'].extend(new_rttm_entries)
+
+            new_json_entry = self.annotator.create_new_json_entry(
+                text=self._text,
+                wav_filename=os.path.join(basepath, filename + '.wav'),
+                start=start / self._params.data_simulator.sr,
+                length=length / self._params.data_simulator.sr,
+                speaker_id=speaker_ids[speaker_turn],
+                rttm_filepath=os.path.join(basepath, filename + '.rttm'),
+                ctm_filepath=os.path.join(basepath, filename + '.ctm'),
+            )
+            self.annotator.annote_lists['json'].append(new_json_entry)
+
+            new_ctm_entries = self.annotator.create_new_ctm_entry(
+                words=self._words,
+                alignments=self._alignments,
+                session_name=filename,
+                speaker_id=speaker_ids[speaker_turn],
+                start=float(start / self._params.data_simulator.sr),
+            )
+
+            self.annotator.annote_lists['ctm'].extend(new_ctm_entries)
+
+            running_len_samples = np.maximum(running_len_samples, end)
+            (
+                self.sampler.running_speech_len_samples,
+                self.sampler.running_silence_len_samples,
+            ) = self._get_session_silence_from_rttm(
+                rttm_list=self.annotator.annote_lists['rttm'], running_len_samples=running_len_samples
+            )
+
+            self._furthest_sample[speaker_turn] = running_len_samples
+            prev_speaker = speaker_turn
+            prev_len_samples = length
+
+        # Step 7-1: Add optional perturbations to the whole session, such as white noise.
+        if self._params.data_simulator.session_augmentor.add_sess_aug:
+            # NOTE: This perturbation is not reflected in the session SNR in meta dictionary.
+            array = perturb_audio(array, self._params.data_simulator.sr, self.session_augmentor, device=array.device)
+
+        # Step 7-2: Additive background noise from noise manifest files
+        if self._params.data_simulator.background_noise.add_bg:
+            if len(self._noise_samples) > 0:
+                avg_power_array = torch.mean(array[is_speech == 1] ** 2)
+                bg, snr = get_background_noise(
+                    len_array=len(array),
+                    power_array=avg_power_array,
+                    noise_samples=self._noise_samples,
+                    audio_read_buffer_dict=self._audio_read_buffer_dict,
+                    snr_min=self._params.data_simulator.background_noise.snr_min,
+                    snr_max=self._params.data_simulator.background_noise.snr_max,
+                    background_noise_snr=self._params.data_simulator.background_noise.snr,
+                    seed=(random_seed + idx),
+                    device=self._device,
+                )
+                array += bg
+            else:
+                raise ValueError('No background noise samples found in self._noise_samples.')
+        else:
+            snr = "N/A"
+
+        # Step 7: Normalize and write to disk
+        array = normalize_audio(array)
+
+        if torch.is_tensor(array):
+            array = array.cpu().numpy()
+        sf.write(os.path.join(basepath, filename + '.wav'), array, self._params.data_simulator.sr)
+
+        self.annotator.write_annotation_files(
+            basepath=basepath,
+            filename=filename,
+            meta_data=self._get_session_meta_data(array=array, snr=snr),
+        )
+
+        # Step 8: Clean up memory
+        del array
+        self.clean_up()
+        return basepath, filename
+
+    def generate_sessions(self, random_seed: int = None):
+        """
+        Generate several multispeaker audio sessions and corresponding list files.
+
+        Args:
+            random_seed (int): random seed for reproducibility
+        """
+        logging.info(f"Generating Diarization Sessions")
+        if random_seed is None:
+            random_seed = self._params.data_simulator.random_seed
+        np.random.seed(random_seed)
+
+        output_dir = self._params.data_simulator.outputs.output_dir
+
+        basepath = get_cleaned_base_path(
+            output_dir, overwrite_output=self._params.data_simulator.outputs.overwrite_output
+        )
+        OmegaConf.save(self._params, os.path.join(output_dir, "params.yaml"))
+
+        tp = concurrent.futures.ProcessPoolExecutor(max_workers=self.num_workers)
+        futures = []
+
+        num_sessions = self._params.data_simulator.session_config.num_sessions
+        source_noise_manifest = read_noise_manifest(
+            add_bg=self._params.data_simulator.background_noise.add_bg,
+            background_manifest=self._params.data_simulator.background_noise.background_manifest,
+        )
+        queue = []
+
+        # add radomly sampled arguments to a list(queue) for multiprocessing
+        for sess_idx in range(num_sessions):
+            filename = self._params.data_simulator.outputs.output_filename + f"_{sess_idx}"
+            speaker_ids = get_speaker_ids(
+                sess_idx=sess_idx,
+                speaker_samples=self._speaker_samples,
+                permutated_speaker_inds=self._permutated_speaker_inds,
+            )
+            speaker_wav_align_map = get_speaker_samples(speaker_ids=speaker_ids, speaker_samples=self._speaker_samples)
+            noise_samples = self.sampler.sample_noise_manifest(noise_manifest=source_noise_manifest)
+
+            if torch.cuda.is_available():
+                device = torch.device(f"cuda:{sess_idx % torch.cuda.device_count()}")
+            else:
+                device = self._device
+            queue.append((sess_idx, basepath, filename, speaker_ids, speaker_wav_align_map, noise_samples, device))
+
+        # for multiprocessing speed, we avoid loading potentially huge manifest list and speaker sample files into each process.
+        if self.num_workers > 1:
+            self._manifest = None
+            self._speaker_samples = None
+
+        # Chunk the sessions into smaller chunks for very large number of sessions (10K+ sessions)
+        for chunk_idx in range(self.chunk_count):
+            futures = []
+            stt_idx, end_idx = (
+                chunk_idx * self.multiprocessing_chunksize,
+                min((chunk_idx + 1) * self.multiprocessing_chunksize, num_sessions),
+            )
+            for sess_idx in range(stt_idx, end_idx):
+                self._furthest_sample = [0 for n in range(self._params.data_simulator.session_config.num_speakers)]
+                self._audio_read_buffer_dict = {}
+                if self.num_workers > 1:
+                    futures.append(tp.submit(self._generate_session, *queue[sess_idx]))
+                else:
+                    futures.append(queue[sess_idx])
+
+            if self.num_workers > 1:
+                generator = concurrent.futures.as_completed(futures)
+            else:
+                generator = futures
+
+            for future in tqdm(
+                generator,
+                desc=f"[{chunk_idx+1}/{self.chunk_count}] Waiting jobs from {stt_idx+1: 2} to {end_idx: 2}",
+                unit="jobs",
+                total=len(futures),
+            ):
+                if self.num_workers > 1:
+                    basepath, filename = future.result()
+                else:
+                    self._noise_samples = self.sampler.sample_noise_manifest(
+                        noise_manifest=source_noise_manifest,
+                    )
+                    basepath, filename = self._generate_session(*future)
+
+                self.annotator.add_to_filename_lists(basepath=basepath, filename=filename)
+
+                # throw warning if number of speakers is less than requested
+                self._check_missing_speakers()
+
+        tp.shutdown()
+        self.annotator.write_filelist_files(basepath=basepath)
+        logging.info(f"Data simulation has been completed, results saved at: {basepath}")
+
+
+class RIRMultiSpeakerSimulator(MultiSpeakerSimulator):
+    """
+    RIR Augmented Multispeaker Audio Session Simulator - simulates multispeaker audio sessions using single-speaker
+    audio files and corresponding word alignments, as well as simulated RIRs for augmentation.
+
+    Args:
+        cfg: OmegaConf configuration loaded from yaml file.
+
+    Parameters (in addition to the base MultiSpeakerSimulator parameters):
+    rir_generation:
+      use_rir (bool): Whether to generate synthetic RIR
+      toolkit (str): Which toolkit to use ("pyroomacoustics", "gpuRIR")
+      room_config:
+        room_sz (list): Size of the shoebox room environment (1d array for specific, 2d array for random range to be
+                        sampled from)
+        pos_src (list): Positions of the speakers in the simulated room environment (2d array for specific, 3d array
+                        for random ranges to be sampled from)
+        noise_src_pos (list): Position in room for the ambient background noise source
+      mic_config:
+        num_channels (int): Number of output audio channels
+        pos_rcv (list): Microphone positions in the simulated room environment (1d/2d array for specific, 2d/3d array
+                        for range assuming num_channels is 1/2+)
+        orV_rcv (list or null): Microphone orientations (needed for non-omnidirectional microphones)
+        mic_pattern (str): Microphone type ("omni" - omnidirectional) - currently only omnidirectional microphones are
+                           supported for pyroomacoustics
+      absorbtion_params: (Note that only `T60` is used for pyroomacoustics simulations)
+        abs_weights (list): Absorption coefficient ratios for each surface
+        T60 (float): Room reverberation time (`T60` is the time it takes for the RIR to decay by 60DB)
+        att_diff (float): Starting attenuation (if this is different than att_max, the diffuse reverberation model is
+                          used by gpuRIR)
+        att_max (float): End attenuation when using the diffuse reverberation model (gpuRIR)
+    """
+
+    def __init__(self, cfg):
+        super().__init__(cfg)
+        self._check_args_rir()
+
+    def _check_args_rir(self):
+        """
+        Checks RIR YAML arguments to ensure they are within valid ranges
+        """
+
+        if not (self._params.data_simulator.rir_generation.toolkit in ['pyroomacoustics', 'gpuRIR']):
+            raise Exception("Toolkit must be pyroomacoustics or gpuRIR")
+        if self._params.data_simulator.rir_generation.toolkit == 'pyroomacoustics' and not PRA:
+            raise ImportError("pyroomacoustics should be installed to run this simulator with RIR augmentation")
+
+        if self._params.data_simulator.rir_generation.toolkit == 'gpuRIR' and not GPURIR:
+            raise ImportError("gpuRIR should be installed to run this simulator with RIR augmentation")
+
+        if len(self._params.data_simulator.rir_generation.room_config.room_sz) != 3:
+            raise Exception("Incorrect room dimensions provided")
+        if self._params.data_simulator.rir_generation.mic_config.num_channels == 0:
+            raise Exception("Number of channels should be greater or equal to 1")
+        if len(self._params.data_simulator.rir_generation.room_config.pos_src) < 2:
+            raise Exception("Less than 2 provided source positions")
+        for sublist in self._params.data_simulator.rir_generation.room_config.pos_src:
+            if len(sublist) != 3:
+                raise Exception("Three coordinates must be provided for sources positions")
+        if len(self._params.data_simulator.rir_generation.mic_config.pos_rcv) == 0:
+            raise Exception("No provided mic positions")
+        for sublist in self._params.data_simulator.rir_generation.room_config.pos_src:
+            if len(sublist) != 3:
+                raise Exception("Three coordinates must be provided for mic positions")
+
+        if self._params.data_simulator.session_config.num_speakers != len(
+            self._params.data_simulator.rir_generation.room_config.pos_src
+        ):
+            raise Exception("Number of speakers is not equal to the number of provided source positions")
+        if self._params.data_simulator.rir_generation.mic_config.num_channels != len(
+            self._params.data_simulator.rir_generation.mic_config.pos_rcv
+        ):
+            raise Exception("Number of channels is not equal to the number of provided microphone positions")
+
+        if (
+            not self._params.data_simulator.rir_generation.mic_config.orV_rcv
+            and self._params.data_simulator.rir_generation.mic_config.mic_pattern != 'omni'
+        ):
+            raise Exception("Microphone orientations must be provided if mic_pattern != omni")
+        if self._params.data_simulator.rir_generation.mic_config.orV_rcv is not None:
+            if len(self._params.data_simulator.rir_generation.mic_config.orV_rcv) != len(
+                self._params.data_simulator.rir_generation.mic_config.pos_rcv
+            ):
+                raise Exception("A different number of microphone orientations and microphone positions were provided")
+            for sublist in self._params.data_simulator.rir_generation.mic_config.orV_rcv:
+                if len(sublist) != 3:
+                    raise Exception("Three coordinates must be provided for orientations")
+
+    def _generate_rir_gpuRIR(self):
+        """
+        Create simulated RIR using the gpuRIR library
+
+        Returns:
+            RIR (tensor): Generated RIR
+            RIR_pad (int): Length of padding added when convolving the RIR with an audio file
+        """
+        room_sz_tmp = np.array(self._params.data_simulator.rir_generation.room_config.room_sz)
+        if room_sz_tmp.ndim == 2:  # randomize
+            room_sz = np.zeros(room_sz_tmp.shape[0])
+            for i in range(room_sz_tmp.shape[0]):
+                room_sz[i] = np.random.uniform(room_sz_tmp[i, 0], room_sz_tmp[i, 1])
+        else:
+            room_sz = room_sz_tmp
+
+        pos_src_tmp = np.array(self._params.data_simulator.rir_generation.room_config.pos_src)
+        if pos_src_tmp.ndim == 3:  # randomize
+            pos_src = np.zeros((pos_src_tmp.shape[0], pos_src_tmp.shape[1]))
+            for i in range(pos_src_tmp.shape[0]):
+                for j in range(pos_src_tmp.shape[1]):
+                    pos_src[i] = np.random.uniform(pos_src_tmp[i, j, 0], pos_src_tmp[i, j, 1])
+        else:
+            pos_src = pos_src_tmp
+
+        if self._params.data_simulator.background_noise.add_bg:
+            pos_src = np.vstack((pos_src, self._params.data_simulator.rir_generation.room_config.noise_src_pos))
+
+        mic_pos_tmp = np.array(self._params.data_simulator.rir_generation.mic_config.pos_rcv)
+        if mic_pos_tmp.ndim == 3:  # randomize
+            mic_pos = np.zeros((mic_pos_tmp.shape[0], mic_pos_tmp.shape[1]))
+            for i in range(mic_pos_tmp.shape[0]):
+                for j in range(mic_pos_tmp.shape[1]):
+                    mic_pos[i] = np.random.uniform(mic_pos_tmp[i, j, 0], mic_pos_tmp[i, j, 1])
+        else:
+            mic_pos = mic_pos_tmp
+
+        orV_rcv = self._params.data_simulator.rir_generation.mic_config.orV_rcv
+        if orV_rcv:  # not needed for omni mics
+            orV_rcv = np.array(orV_rcv)
+        mic_pattern = self._params.data_simulator.rir_generation.mic_config.mic_pattern
+        abs_weights = self._params.data_simulator.rir_generation.absorbtion_params.abs_weights
+        T60 = self._params.data_simulator.rir_generation.absorbtion_params.T60
+        att_diff = self._params.data_simulator.rir_generation.absorbtion_params.att_diff
+        att_max = self._params.data_simulator.rir_generation.absorbtion_params.att_max
+        sr = self._params.data_simulator.sr
+
+        beta = beta_SabineEstimation(room_sz, T60, abs_weights=abs_weights)  # Reflection coefficients
+        Tdiff = att2t_SabineEstimator(att_diff, T60)  # Time to start the diffuse reverberation model [s]
+        Tmax = att2t_SabineEstimator(att_max, T60)  # Time to stop the simulation [s]
+        nb_img = t2n(Tdiff, room_sz)  # Number of image sources in each dimension
+        RIR = simulateRIR(
+            room_sz, beta, pos_src, mic_pos, nb_img, Tmax, sr, Tdiff=Tdiff, orV_rcv=orV_rcv, mic_pattern=mic_pattern
+        )
+        RIR_pad = RIR.shape[2] - 1
+        return RIR, RIR_pad
+
+    def _generate_rir_pyroomacoustics(self) -> Tuple[torch.Tensor, int]:
+        """
+        Create simulated RIR using the pyroomacoustics library
+
+        Returns:
+            RIR (tensor): Generated RIR
+            RIR_pad (int): Length of padding added when convolving the RIR with an audio file
+        """
+
+        rt60 = self._params.data_simulator.rir_generation.absorbtion_params.T60  # The desired reverberation time
+        sr = self._params.data_simulator.sr
+
+        room_sz_tmp = np.array(self._params.data_simulator.rir_generation.room_config.room_sz)
+        if room_sz_tmp.ndim == 2:  # randomize
+            room_sz = np.zeros(room_sz_tmp.shape[0])
+            for i in range(room_sz_tmp.shape[0]):
+                room_sz[i] = np.random.uniform(room_sz_tmp[i, 0], room_sz_tmp[i, 1])
+        else:
+            room_sz = room_sz_tmp
+
+        pos_src_tmp = np.array(self._params.data_simulator.rir_generation.room_config.pos_src)
+        if pos_src_tmp.ndim == 3:  # randomize
+            pos_src = np.zeros((pos_src_tmp.shape[0], pos_src_tmp.shape[1]))
+            for i in range(pos_src_tmp.shape[0]):
+                for j in range(pos_src_tmp.shape[1]):
+                    pos_src[i] = np.random.uniform(pos_src_tmp[i, j, 0], pos_src_tmp[i, j, 1])
+        else:
+            pos_src = pos_src_tmp
+
+        # We invert Sabine's formula to obtain the parameters for the ISM simulator
+        e_absorption, max_order = pra.inverse_sabine(rt60, room_sz)
+        room = pra.ShoeBox(room_sz, fs=sr, materials=pra.Material(e_absorption), max_order=max_order)
+
+        if self._params.data_simulator.background_noise.add_bg:
+            pos_src = np.vstack((pos_src, self._params.data_simulator.rir_generation.room_config.noise_src_pos))
+        for pos in pos_src:
+            room.add_source(pos)
+
+        # currently only supports omnidirectional microphones
+        mic_pattern = self._params.data_simulator.rir_generation.mic_config.mic_pattern
+        if self._params.data_simulator.rir_generation.mic_config.mic_pattern == 'omni':
+            mic_pattern = DirectivityPattern.OMNI
+            dir_vec = DirectionVector(azimuth=0, colatitude=90, degrees=True)
+        dir_obj = CardioidFamily(
+            orientation=dir_vec,
+            pattern_enum=mic_pattern,
+        )
+
+        mic_pos_tmp = np.array(self._params.data_simulator.rir_generation.mic_config.pos_rcv)
+        if mic_pos_tmp.ndim == 3:  # randomize
+            mic_pos = np.zeros((mic_pos_tmp.shape[0], mic_pos_tmp.shape[1]))
+            for i in range(mic_pos_tmp.shape[0]):
+                for j in range(mic_pos_tmp.shape[1]):
+                    mic_pos[i] = np.random.uniform(mic_pos_tmp[i, j, 0], mic_pos_tmp[i, j, 1])
+        else:
+            mic_pos = mic_pos_tmp
+
+        room.add_microphone_array(mic_pos.T, directivity=dir_obj)
+
+        room.compute_rir()
+        rir_pad = 0
+        for channel in room.rir:
+            for pos in channel:
+                if pos.shape[0] - 1 > rir_pad:
+                    rir_pad = pos.shape[0] - 1
+        return room.rir, rir_pad
+
+    def _convolve_rir(self, input, speaker_turn: int, RIR: torch.Tensor) -> Tuple[list, int]:
+        """
+        Augment one sentence (or background noise segment) using a synthetic RIR.
+
+        Args:
+            input (torch.tensor): Input audio.
+            speaker_turn (int): Current speaker turn.
+            RIR (torch.tensor): Room Impulse Response.
+        Returns:
+            output_sound (list): List of tensors containing augmented audio
+            length (int): Length of output audio channels (or of the longest if they have different lengths)
+        """
+        output_sound = []
+        length = 0
+        for channel in range(self._params.data_simulator.rir_generation.mic_config.num_channels):
+            if self._params.data_simulator.rir_generation.toolkit == 'gpuRIR':
+                out_channel = convolve(input, RIR[speaker_turn, channel, : len(input)]).tolist()
+            elif self._params.data_simulator.rir_generation.toolkit == 'pyroomacoustics':
+                out_channel = convolve(input, RIR[channel][speaker_turn][: len(input)]).tolist()
+            if len(out_channel) > length:
+                length = len(out_channel)
+            output_sound.append(torch.tensor(out_channel))
+        return output_sound, length
+
+    def _generate_session(
+        self,
+        idx: int,
+        basepath: str,
+        filename: str,
+        speaker_ids: list,
+        speaker_wav_align_map: dict,
+        noise_samples: list,
+        device: torch.device,
+        enforce_counter: int = 2,
+    ):
+        """
+        Generate a multispeaker audio session and corresponding label files.
+
+        Args:
+            idx (int): Index for current session (out of total number of sessions).
+            basepath (str): Path to output directory.
+            filename (str): Filename for output files.
+            speaker_ids (list): List of speaker IDs that will be used in this session.
+            speaker_wav_align_map (dict): Dictionary containing speaker IDs and their corresponding wav filepath and alignments.
+            noise_samples (list): List of randomly sampled noise source files that will be used for generating this session.
+            device (torch.device): Device to use for generating this session.
+            enforce_counter (int): In enforcement mode, dominance is increased by a factor of enforce_counter for unrepresented speakers
+        """
+        random_seed = self._params.data_simulator.random_seed
+        np.random.seed(random_seed + idx)
+
+        self._device = device
+        speaker_dominance = self._get_speaker_dominance()  # randomly determine speaker dominance
+        base_speaker_dominance = np.copy(speaker_dominance)
+        self._set_speaker_volume()
+
+        running_len_samples, prev_len_samples = 0, 0  # starting point for each sentence
+        prev_speaker = None
+        self.annotator.init_annotation_lists()
+        self._noise_samples = noise_samples
+        self._furthest_sample = [0 for n in range(self._params.data_simulator.session_config.num_speakers)]
+
+        # Room Impulse Response Generation (performed once per batch of sessions)
+        if self._params.data_simulator.rir_generation.toolkit == 'gpuRIR':
+            RIR, RIR_pad = self._generate_rir_gpuRIR()
+        elif self._params.data_simulator.rir_generation.toolkit == 'pyroomacoustics':
+            RIR, RIR_pad = self._generate_rir_pyroomacoustics()
+        else:
+            raise Exception("Toolkit must be pyroomacoustics or gpuRIR")
+
+        # hold enforce until all speakers have spoken
+        enforce_time = np.random.uniform(
+            self._params.data_simulator.speaker_enforcement.enforce_time[0],
+            self._params.data_simulator.speaker_enforcement.enforce_time[1],
+        )
+        enforce = self._params.data_simulator.speaker_enforcement.enforce_num_speakers
+
+        session_len_samples = int(
+            (self._params.data_simulator.session_config.session_length * self._params.data_simulator.sr)
+        )
+        array = torch.zeros((session_len_samples, self._params.data_simulator.rir_generation.mic_config.num_channels))
+        is_speech = torch.zeros(session_len_samples)
+
+        while running_len_samples < session_len_samples or enforce:
+            # Step 1: Prepare parameters for sentence generation
+            # Enforce speakers depending on running length
+            if running_len_samples > enforce_time * session_len_samples and enforce:
+                speaker_dominance, enforce = self._increase_speaker_dominance(base_speaker_dominance, enforce_counter)
+                if enforce:
+                    enforce_counter += 1
+
+            # Step 2: Select a speaker
+            speaker_turn = self._get_next_speaker(prev_speaker, speaker_dominance)
+
+            # Calculate parameters for building a sentence (only add if remaining length >  specific time)
+            max_samples_in_sentence = (
+                session_len_samples - running_len_samples - RIR_pad
+            )  # sentence will be RIR_len - 1 longer than the audio was pre-augmentation
+            if enforce:
+                max_samples_in_sentence = float('inf')
+            elif (
+                max_samples_in_sentence
+                < self._params.data_simulator.session_params.end_buffer * self._params.data_simulator.sr
+            ):
+                break
+
+            # Step 3: Generate a sentence
+            self._build_sentence(speaker_turn, speaker_ids, speaker_wav_align_map, max_samples_in_sentence)
+            augmented_sentence, length = self._convolve_rir(self._sentence, speaker_turn, RIR)
+
+            # Step 4: Generate a time-stamp for either silence or overlap
+            start = self._add_silence_or_overlap(
+                speaker_turn=speaker_turn,
+                prev_speaker=prev_speaker,
+                start=running_len_samples,
+                length=length,
+                session_len_samples=session_len_samples,
+                prev_len_samples=prev_len_samples,
+                enforce=enforce,
+            )
+            # step 5: add sentence to array
+            end = start + length
+            if end > len(array):
+                array = torch.nn.functional.pad(array, (0, 0, 0, end - len(array)))
+                is_speech = torch.nn.functional.pad(is_speech, (0, end - len(is_speech)))
+            is_speech[start:end] = 1
+
+            for channel in range(self._params.data_simulator.rir_generation.mic_config.num_channels):
+                len_ch = len(augmented_sentence[channel])  # accounts for how channels are slightly different lengths
+                array[start : start + len_ch, channel] += augmented_sentence[channel]
+
+            # Step 6: Build entries for output files
+            new_rttm_entries = self.annotator.create_new_rttm_entry(
+                self._words,
+                self._alignments,
+                start / self._params.data_simulator.sr,
+                end / self._params.data_simulator.sr,
+                speaker_ids[speaker_turn],
+            )
+
+            self.annotator.annote_lists['rttm'].extend(new_rttm_entries)
+
+            new_json_entry = self.annotator.create_new_json_entry(
+                self._text,
+                os.path.join(basepath, filename + '.wav'),
+                start / self._params.data_simulator.sr,
+                length / self._params.data_simulator.sr,
+                speaker_ids[speaker_turn],
+                os.path.join(basepath, filename + '.rttm'),
+                os.path.join(basepath, filename + '.ctm'),
+            )
+            self.annotator.annote_lists['json'].append(new_json_entry)
+
+            new_ctm_entries = self.annotator.create_new_ctm_entry(
+                filename, speaker_ids[speaker_turn], start / self._params.data_simulator.sr
+            )
+            self.annotator.annote_lists['ctm'].extend(new_ctm_entries)
+
+            running_len_samples = np.maximum(running_len_samples, end)
+            self._furthest_sample[speaker_turn] = running_len_samples
+            prev_speaker = speaker_turn
+            prev_len_samples = length
+
+        # Step 7-1: Add optional perturbations to the whole session, such as white noise.
+        if self._params.data_simulator.session_augmentor.add_sess_aug:
+            # NOTE: This perturbation is not reflected in the session SNR in meta dictionary.
+            array = perturb_audio(array, self._params.data_simulator.sr, self.session_augmentor)
+
+        # Step 7-2: Additive background noise from noise manifest files
+        if self._params.data_simulator.background_noise.add_bg:
+            if len(self._noise_samples) > 0:
+                avg_power_array = torch.mean(array[is_speech == 1] ** 2)
+                bg, snr = get_background_noise(
+                    len_array=len(array),
+                    power_array=avg_power_array,
+                    noise_samples=self._noise_samples,
+                    audio_read_buffer_dict=self._audio_read_buffer_dict,
+                    snr_min=self._params.data_simulator.background_noise.snr_min,
+                    snr_max=self._params.data_simulator.background_noise.snr_max,
+                    background_noise_snr=self._params.data_simulator.background_noise.snr,
+                    seed=(random_seed + idx),
+                    device=self._device,
+                )
+                array += bg
+            length = array.shape[0]
+            bg, snr = self._get_background(length, avg_power_array)
+            augmented_bg, _ = self._convolve_rir(bg, -1, RIR)
+            for channel in range(self._params.data_simulator.rir_generation.mic_config.num_channels):
+                array[:, channel] += augmented_bg[channel][:length]
+        else:
+            snr = "N/A"
+
+        # Step 7: Normalize and write to disk
+        array = normalize_audio(array)
+
+        if torch.is_tensor(array):
+            array = array.cpu().numpy()
+        sf.write(os.path.join(basepath, filename + '.wav'), array, self._params.data_simulator.sr)
+
+        self.annotator.write_annotation_files(
+            basepath=basepath,
+            filename=filename,
+            meta_data=self._get_session_meta_data(array=array, snr=snr),
+        )
+
+        del array
+        self.clean_up()
+        return basepath, filename

nemo/collections/asr/data/feature_to_label.py

@@ -0,0 +1,497 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+from typing import Dict, List, Optional
+
+import torch
+
+from nemo.collections.asr.parts.preprocessing.feature_loader import ExternalFeatureLoader
+from nemo.collections.common.parts.preprocessing import collections
+from nemo.core.classes import Dataset
+from nemo.core.neural_types import AcousticEncodedRepresentation, LabelsType, LengthsType, NeuralType
+from nemo.utils import logging
+
+
+def _feature_collate_fn(batch):
+    """collate batch of feat sig, feat len, labels, labels len, assuming all features have the same shape.
+    Args:
+        batch (FloatTensor, LongTensor, LongTensor, LongTensor):  A tuple of tuples of feature, feature lengths,
+               encoded labels, and encoded labels length. 
+    """
+    packed_batch = list(zip(*batch))
+    if len(packed_batch) == 5:
+        _, feat_lengths, _, labels_lengths, sample_ids = packed_batch
+    elif len(packed_batch) == 4:
+        sample_ids = None
+        _, feat_lengths, _, labels_lengths = packed_batch
+    else:
+        raise ValueError("Expects 4 or 5 tensors in the batch!")
+
+    features, labels = [], []
+    for b in batch:
+        feat_i, labels_i = b[0], b[2]
+        features.append(feat_i)
+        labels.append(labels_i)
+
+    features = torch.stack(features)
+    feat_lengths = torch.stack(feat_lengths)
+
+    labels = torch.stack(labels)
+    labels_lengths = torch.stack(labels_lengths)
+
+    if sample_ids is None:
+        return features, feat_lengths, labels, labels_lengths
+    else:
+        sample_ids = torch.tensor(sample_ids, dtype=torch.int32)
+        return features, feat_lengths, labels, labels_lengths, sample_ids
+
+
+def _audio_feature_collate_fn(batch, feat_pad_val, label_pad_id):
+    """collate batch of audio feature, audio len, labels, labels len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+               LongTensor):  A tuple of tuples of feature, feature lengths,
+               labels, and label lengths.  This collate func assumes the 
+               features are torch tensors of Log-Melspectrogram (i.e. [N_MEL, T]).
+    """
+    packed_batch = list(zip(*batch))
+    if len(packed_batch) == 5:
+        _, feat_lengths, _, labels_lengths, sample_ids = packed_batch
+    elif len(packed_batch) == 4:
+        sample_ids = None
+        _, feat_lengths, _, labels_lengths = packed_batch
+    else:
+        raise ValueError("Expects 4 or 5 tensors in the batch!")
+    max_feat_len = 0
+    has_feat = feat_lengths[0] is not None
+    if has_feat:
+        max_feat_len = max(feat_lengths).item()
+    max_labels_len = max(labels_lengths).item()
+
+    features, labels = [], []
+    for b in batch:
+        feat_i, feat_i_len, label_i, label_i_len = b[0], b[1], b[2], b[3]
+
+        if has_feat:
+            feat_i_len = feat_i_len.item()
+            if feat_i_len < max_feat_len:
+                pad = (0, max_feat_len - feat_i_len)
+                feat_i = torch.nn.functional.pad(feat_i, pad, value=feat_pad_val)
+            features.append(feat_i)
+
+        label_i_len = label_i_len.item()
+        if label_i_len < max_labels_len:
+            pad = (0, max_labels_len - label_i_len)
+            label_i = torch.nn.functional.pad(label_i, pad, value=label_pad_id)
+        labels.append(label_i)
+
+    if has_feat:
+        features = torch.stack(features)
+        feature_lengths = torch.stack(feat_lengths)
+    else:
+        features, feat_lengths = None, None
+    labels = torch.stack(labels)
+    labels_lengths = torch.stack(labels_lengths)
+
+    if sample_ids is None:
+        return features, feature_lengths, labels, labels_lengths
+    else:
+        sample_ids = torch.tensor(sample_ids, dtype=torch.int32)
+        return features, feature_lengths, labels, labels_lengths, sample_ids
+
+
+def _vad_feature_segment_collate_fn(batch, window_length_in_sec, shift_length_in_sec, frame_unit_in_sec):
+    """collate batch of audio features, features len, tokens, tokens len
+    Args:
+        batch (Optional[FloatTensor], Optional[LongTensor], LongTensor,
+            LongTensor):  A tuple of tuples of signal, signal lengths,
+            encoded tokens, and encoded tokens length.  This collate func
+            assumes the signals are 1d torch tensors (i.e. mono audio).
+            batch size equals to 1.
+    """
+    slice_length = int(window_length_in_sec / frame_unit_in_sec)
+    audio_features, feat_lengths, _, tokens_lengths = zip(*batch)
+
+    slice_length = int(min(slice_length, max(feat_lengths)))
+    shift = int(shift_length_in_sec / frame_unit_in_sec)
+    has_audio = feat_lengths[0] is not None
+
+    f_dim = audio_features[0].shape[0]
+    audio_features, num_slices, tokens, feat_lengths = [], [], [], []
+    append_len_start = torch.div(slice_length, 2, rounding_mode='trunc')
+    append_len_end = slice_length - torch.div(slice_length, 2, rounding_mode='trunc')
+    for feat_i, feat_i_len, tokens_i, _ in batch:
+        start = torch.zeros(f_dim, append_len_start)
+        end = torch.zeros(f_dim, append_len_end)
+        feat_i = torch.cat((start, feat_i, end), dim=1)
+        feat_i_len += slice_length
+
+        if has_audio:
+            slices = max(1, torch.div(feat_i_len - slice_length, shift, rounding_mode='trunc'))
+
+            for slice_id in range(slices):
+                start_idx = slice_id * shift
+                end_idx = start_idx + slice_length
+                feat_slice = feat_i[:, start_idx:end_idx]
+                audio_features.append(feat_slice)
+
+            num_slices.append(slices)
+            tokens.extend([tokens_i] * slices)
+            feat_lengths.extend([slice_length] * slices)
+
+    if has_audio:
+        audio_features = torch.stack(audio_features)
+        feat_lengths = torch.tensor(feat_lengths)
+    else:
+        audio_features, feat_lengths = None, None
+
+    tokens = torch.stack(tokens)
+    tokens_lengths = torch.tensor(num_slices)
+    return audio_features, feat_lengths, tokens, tokens_lengths
+
+
+class _FeatureSeqSpeakerLabelDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to feature files, sequences of labels. 
+    Each new line is a different sample. Example below:
+    and their target labels. JSON files should be of the following format:
+        {"feature_filepath": "/path/to/feature_0.p", "seq_label": speakerA speakerB SpeakerA ....} \
+        ...
+        {"feature_filepath": "/path/to/feature_n.p", "seq_label": target_seq_label_n} 
+    target_seq_label_n is the string of sequence of speaker label, separated by space.
+
+    Args:
+        manifest_filepath (str): Dataset parameter. Path to JSON containing data.
+        labels (Optional[list]): Dataset parameter. List of unique labels collected from all samples.
+        feature_loader : Dataset parameter. Feature loader to load (external) feature.       
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports.
+        """
+        # TODO output type for external features
+        output_types = {
+            'external_feat': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
+            'feat_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        if self.is_speaker_emb:
+            output_types.update(
+                {
+                    'embs': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
+                    'embs_length': NeuralType(tuple('B'), LengthsType()),
+                    'label': NeuralType(('B', 'T'), LabelsType()),
+                    'label_length': NeuralType(tuple('B'), LengthsType()),
+                }
+            )
+        else:
+            output_types.update(
+                {'label': NeuralType(('B', 'T'), LabelsType()), 'label_length': NeuralType(tuple('B'), LengthsType()),}
+            )
+
+        return output_types
+
+    def __init__(
+        self, *, manifest_filepath: str, labels: List[str], feature_loader, is_speaker_emb: bool = False,
+    ):
+        super().__init__()
+        self.collection = collections.ASRFeatureSequenceLabel(manifests_files=manifest_filepath.split(','),)
+
+        self.feature_loader = feature_loader
+        self.labels = labels if labels else self.collection.uniq_labels
+        self.is_speaker_emb = is_speaker_emb
+
+        self.label2id, self.id2label = {}, {}
+        for label_id, label in enumerate(self.labels):
+            self.label2id[label] = label_id
+            self.id2label[label_id] = label
+
+        for idx in range(len(self.labels[:5])):
+            logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+
+    def __len__(self):
+        return len(self.collection)
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        features = self.feature_loader.process(sample.feature_file)
+        f, fl = features, torch.tensor(features.shape[0]).long()
+
+        t = torch.tensor(sample.seq_label).float()
+        tl = torch.tensor(len(sample.seq_label)).long()
+
+        return f, fl, t, tl
+
+
+class FeatureToSeqSpeakerLabelDataset(_FeatureSeqSpeakerLabelDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to feature
+    files and sequence of speakers. Each new line is a
+    different sample. Example below:
+    {"feature_filepath": "/path/to/feature_0.p", "seq_label": speakerA speakerB SpeakerA ....} \
+    ...
+    {"feature_filepath": "/path/to/feature_n.p", "seq_label": target_seq_label_n} 
+    target_seq_label_n is the string of sequence of speaker label, separated by space.
+
+    Args:
+        manifest_filepath (str): Path to manifest json as described above. Canbe comma-separated paths.
+        labels (Optional[list]): String containing all the possible labels to map to
+            if None then automatically picks from ASRFeatureSequenceLabel collection.
+        feature_loader, Feature load to loader (external) feature.
+    
+    """
+
+    def _collate_fn(self, batch):
+        return _feature_collate_fn(batch)
+
+
+class FeatureToLabelDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to feature files and their labels. 
+    Each new line is a different sample. Example below:
+    and their target labels. JSON files should be of the following format:
+        {"feature_filepath": "/path/to/audio_feature.pt", "label": "1"}
+        ...
+        {"feature_filepath": "/path/to/audio_feature.pt", "label": "0"} 
+    Args:
+        manifest_filepath (str): Path to JSON containing data.
+        labels (Optional[list]): List of unique labels collected from all samples.
+        augmentor (Optional): feature augmentation
+        window_length_in_sec (float): Window length in seconds.
+        shift_length_in_sec (float): Shift length in seconds.
+        is_regression_task (bool): if True, the labels are treated as for a regression task.
+        cal_labels_occurrence (bool): if True, the labels occurrence will be calculated.
+        zero_spec_db_val (float): Value to replace non-speech signals in log-melspectrogram.
+        min_duration (float): Minimum duration of the audio file in seconds.
+        max_duration (float): Maximum duration of the audio file in seconds.
+    """
+
+    ZERO_LEVEL_SPEC_DB_VAL = -16.635  # Log-Melspectrogram value for zero signal
+    FRAME_UNIT_TIME_SECS = 0.01
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports.
+        """
+        output_types = {
+            'audio_feat': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
+            'feat_length': NeuralType(tuple('B'), LengthsType()),
+            'labels': NeuralType(('B'), LabelsType()),
+            'labels_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        labels: List[str] = None,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        window_length_in_sec: float = 0.63,
+        shift_length_in_sec: float = 0.01,
+        is_regression_task: bool = False,
+        cal_labels_occurrence: Optional[bool] = False,
+        zero_spec_db_val: float = -16.635,
+        min_duration: Optional[float] = None,
+        max_duration: Optional[float] = None,
+    ):
+        super().__init__()
+        self.window_length_in_sec = window_length_in_sec
+        self.shift_length_in_sec = shift_length_in_sec
+        self.zero_spec_db_val = zero_spec_db_val
+
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(',')
+
+        self.collection = collections.ASRFeatureLabel(
+            manifests_files=manifest_filepath,
+            is_regression_task=is_regression_task,
+            cal_labels_occurrence=cal_labels_occurrence,
+            min_duration=min_duration,
+            max_duration=max_duration,
+        )
+
+        self.feature_loader = ExternalFeatureLoader(augmentor=augmentor)
+        self.labels = labels if labels else self.collection.uniq_labels
+
+        self.is_regression_task = is_regression_task
+
+        if not is_regression_task:
+            self.labels = labels if labels else self.collection.uniq_labels
+            self.num_classes = len(self.labels) if self.labels is not None else 1
+            self.label2id, self.id2label = {}, {}
+            self.id2occurrence, self.labels_occurrence = {}, []
+
+            for label_id, label in enumerate(self.labels):
+                self.label2id[label] = label_id
+                self.id2label[label_id] = label
+                if cal_labels_occurrence:
+                    self.id2occurrence[label_id] = self.collection.labels_occurrence[label]
+
+            if cal_labels_occurrence:
+                self.labels_occurrence = [self.id2occurrence[k] for k in sorted(self.id2occurrence)]
+
+            for idx in range(len(self.labels[:5])):
+                logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+        else:
+            self.labels = []
+            self.num_classes = 1
+
+    def __len__(self):
+        return len(self.collection)
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        features = self.feature_loader.process(sample.feature_file)
+        f, fl = features, torch.tensor(features.shape[1]).long()
+
+        t = torch.tensor(self.label2id[sample.label])
+        tl = torch.tensor(1).long()
+
+        return f, fl, t, tl
+
+    def _collate_fn(self, batch):
+        return _audio_feature_collate_fn(batch, self.zero_spec_db_val, 0)
+
+    def _vad_segment_collate_fn(self, batch):
+        return _vad_feature_segment_collate_fn(
+            batch, self.window_length_in_sec, self.shift_length_in_sec, self.FRAME_UNIT_TIME_SECS
+        )
+
+
+class FeatureToMultiLabelDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to feature files and their labels. 
+    Each new line is a different sample. Example below:
+    and their target labels. JSON files should be of the following format:
+        {"feature_filepath": "/path/to/audio_feature.pt", "label": "1 1 0 0 1"}
+        ...
+        {"feature_filepath": "/path/to/audio_feature.pt", "label": "0 1 0 0"} 
+    Args:
+        manifest_filepath (str): Path to JSON containing data.
+        labels (Optional[list]): List of unique labels collected from all samples.
+        augmentor (Optional): feature augmentation
+        delimiter (str): delimiter to split the labels.
+        is_regression_task (bool): if True, the labels are treated as for a regression task.
+        cal_labels_occurrence (bool): if True, the labels occurrence will be calculated.
+        zero_spec_db_val (float): Value to replace non-speech signals in log-melspectrogram.
+        min_duration (float): Minimum duration of the audio file in seconds.
+        max_duration (float): Maximum duration of the audio file in seconds.
+    """
+
+    ZERO_LEVEL_SPEC_DB_VAL = -16.635  # Log-Melspectrogram value for zero signal
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports.
+        """
+        output_types = {
+            'audio_feat': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
+            'feat_length': NeuralType(tuple('B'), LengthsType()),
+            'labels': NeuralType(('B', 'T'), LabelsType()),
+            'labels_length': NeuralType(tuple('B'), LengthsType()),
+        }
+
+        return output_types
+
+    def __init__(
+        self,
+        *,
+        manifest_filepath: str,
+        labels: List[str] = None,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        delimiter: Optional[str] = None,
+        is_regression_task: bool = False,
+        cal_labels_occurrence: Optional[bool] = False,
+        zero_spec_db_val: float = -16.635,
+        min_duration: Optional[float] = None,
+        max_duration: Optional[float] = None,
+    ):
+        super().__init__()
+        self.delimiter = delimiter
+        self.zero_spec_db_val = zero_spec_db_val
+
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(',')
+
+        self.collection = collections.ASRFeatureLabel(
+            manifests_files=manifest_filepath,
+            is_regression_task=is_regression_task,
+            cal_labels_occurrence=cal_labels_occurrence,
+            delimiter=delimiter,
+            min_duration=min_duration,
+            max_duration=max_duration,
+        )
+
+        self.is_regression_task = is_regression_task
+        self.feature_loader = ExternalFeatureLoader(augmentor=augmentor)
+        self.labels = labels if labels else self.collection.uniq_labels
+
+        self.label2id, self.id2label = {}, {}
+        if not is_regression_task:
+            self.labels = labels if labels else self._get_label_set()
+            self.num_classes = len(self.labels) if self.labels is not None else 1
+            self.label2id, self.id2label = {}, {}
+            for label_id, label in enumerate(self.labels):
+                self.label2id[label] = label_id
+                self.id2label[label_id] = label
+                if cal_labels_occurrence:
+                    self.id2occurrence[label_id] = self.collection.labels_occurrence[label]
+                    self.labels_occurrence.append(self.id2occurrence[label_id])
+
+            for idx in range(len(self.labels[:5])):
+                logging.debug(" label id {} and its mapped label {}".format(idx, self.id2label[idx]))
+        else:
+            self.labels = []
+            self.num_classes = 1
+
+    def _get_label_set(self):
+        labels = []
+        for sample in self.collection:
+            label_str = sample.label
+            if label_str:
+                label_str_list = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+                labels.extend(label_str_list)
+        return sorted(set(labels))
+
+    def _label_str_to_tensor(self, label_str: str):
+        labels = label_str.split(self.delimiter) if self.delimiter else label_str.split()
+
+        if self.is_regression_task:
+            labels = [float(s) for s in labels]
+            labels = torch.tensor(labels).float()
+        else:
+            labels = [self.label2id[s] for s in labels]
+            labels = torch.tensor(labels).long()
+        return labels
+
+    def __len__(self):
+        return len(self.collection)
+
+    def __getitem__(self, index):
+        sample = self.collection[index]
+
+        features = self.feature_loader.process(sample.feature_file)
+        f, fl = features, torch.tensor(features.shape[1]).long()
+
+        t = self._label_str_to_tensor(sample.label)
+        tl = torch.tensor(t.size(0)).long()
+
+        return f, fl, t, tl
+
+    def _collate_fn(self, batch):
+        return _audio_feature_collate_fn(batch, self.zero_spec_db_val, 0)

nemo/collections/asr/data/feature_to_label_dataset.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+from typing import Optional
+
+from nemo.collections.asr.data import feature_to_label
+
+
+def get_feature_seq_speakerlabel_dataset(
+    feature_loader, config: dict
+) -> feature_to_label.FeatureToSeqSpeakerLabelDataset:
+    """
+    Instantiates a FeatureSeqSpeakerLabelDataset.
+    Args:
+        config: Config of the FeatureToSeqSpeakerLabelDataset.
+
+    Returns:
+        An instance of FeatureToSeqSpeakerLabelDataset.
+    """
+    dataset = feature_to_label.FeatureToSeqSpeakerLabelDataset(
+        manifest_filepath=config['manifest_filepath'], labels=config['labels'], feature_loader=feature_loader,
+    )
+    return dataset
+
+
+def get_feature_label_dataset(
+    config: dict, augmentor: Optional['FeatureAugmentor'] = None
+) -> feature_to_label.FeatureToLabelDataset:
+    dataset = feature_to_label.FeatureToLabelDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config['labels'],
+        augmentor=augmentor,
+        window_length_in_sec=config.get("window_length_in_sec", 0.63),
+        shift_length_in_sec=config.get("shift_length_in_sec", 0.08),
+        is_regression_task=config.get("is_regression_task", False),
+        cal_labels_occurrence=config.get("cal_labels_occurrence", False),
+        zero_spec_db_val=config.get("zero_spec_db_val", -16.635),
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+    )
+    return dataset
+
+
+def get_feature_multi_label_dataset(
+    config: dict, augmentor: Optional['FeatureAugmentor'] = None
+) -> feature_to_label.FeatureToMultiLabelDataset:
+    dataset = feature_to_label.FeatureToMultiLabelDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config['labels'],
+        augmentor=augmentor,
+        delimiter=config.get('delimiter', None),
+        is_regression_task=config.get("is_regression_task", False),
+        cal_labels_occurrence=config.get("cal_labels_occurrence", False),
+        zero_spec_db_val=config.get("zero_spec_db_val", -16.635),
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+    )
+    return dataset

nemo/collections/asr/data/feature_to_text.py

@@ -0,0 +1,487 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+import torch
+
+from nemo.collections.asr.data.feature_to_label import _audio_feature_collate_fn
+from nemo.collections.asr.parts.preprocessing.feature_loader import ExternalFeatureLoader
+from nemo.collections.asr.parts.preprocessing.features import normalize_batch
+from nemo.collections.asr.parts.preprocessing.segment import ChannelSelectorType
+from nemo.collections.asr.parts.utils.vad_utils import load_speech_segments_from_rttm
+from nemo.collections.common import tokenizers
+from nemo.collections.common.parts.preprocessing import collections, parsers
+from nemo.core.classes import Dataset
+from nemo.core.neural_types import AcousticEncodedRepresentation, LabelsType, LengthsType, NeuralType
+
+
+class ASRFeatureManifestProcessor:
+    def __init__(
+        self,
+        manifest_filepath: str,
+        parser: Union[str, Callable],
+        max_duration: Optional[float] = None,
+        min_duration: Optional[float] = None,
+        max_utts: int = 0,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        index_by_file_id: bool = False,
+    ):
+        self.parser = parser
+        self.collection = collections.ASRFeatureText(
+            manifests_files=manifest_filepath,
+            parser=parser,
+            min_duration=min_duration,
+            max_duration=max_duration,
+            max_number=max_utts,
+            index_by_file_id=index_by_file_id,
+        )
+
+        self.eos_id = eos_id
+        self.bos_id = bos_id
+        self.pad_id = pad_id
+
+    def process_text_by_id(self, index: int) -> Tuple[List[int], int]:
+        sample = self.collection[index]
+        return self.process_text_by_sample(sample)
+
+    def process_text_by_file_id(self, file_id: str) -> Tuple[List[int], int]:
+        manifest_idx = self.collection.mapping[file_id][0]
+        sample = self.collection[manifest_idx]
+        return self.process_text_by_sample(sample)
+
+    def process_text_by_sample(self, sample: collections.ASRAudioText.OUTPUT_TYPE) -> Tuple[List[int], int]:
+        t, tl = sample.text_tokens, len(sample.text_tokens)
+
+        if self.bos_id is not None:
+            t = [self.bos_id] + t
+            tl += 1
+        if self.eos_id is not None:
+            t = t + [self.eos_id]
+            tl += 1
+
+        return t, tl
+
+
+class _FeatureTextDataset(Dataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio feature files, transcripts,
+    durations (in seconds) and optional RTTM files. Each new line is a different sample. Example below:
+    {"feature_filepath": "/path/to/audio_feature.pt", "text_filepath": "/path/to/audio.txt",
+    "rttm_filepath": "/path/to/audio_rttm.rttm", "duration": 23.147}
+    ...
+    {"feature_filepath": "/path/to/audio_feature.pt", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+    Args:
+        manifest_filepath (str): Path to manifest json as described above. Can be comma-separated paths.
+        parser: Str for a language specific preprocessor or a callable.
+        normalize (bool): whether and where to normalize feature, must be one of [None, "post_norm", "pre_norm"]
+        normalize_type (Union[str, dict]): how to normalize feature, see `nemo.collections.asr.parts.preprocessing.features.normalize_batch`
+        use_rttm (bool): whether to use RTTM files if there is any, default to False
+        rttm_mode (str): how to use RTTM files, must be one of ['mask', 'drop'], default to 'mask'
+        feat_min_len (int): minimum length of feature when rttm_mode=deop, default to 4.
+        feat_mask_val (Optional[float]): value used to mask features with RTTM files, default to None to use zero mel-spectralgram
+        frame_unit_time_secs (float): time in seconds for each frame
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor object used to augment loaded audio
+        max_duration (float): If audio exceeds this length, do not include in dataset
+        min_duration (float): If audio is less than this length, do not include in dataset
+        max_utts (int): Limit number of utterances
+        trim (bool): whether or not to trim silence. Defaults to False
+        bos_id (int): Id of beginning of sequence symbol to append if not None
+        eos_id (int): Id of end of sequence symbol to append if not None
+        pad_id (int): Id of pad symbol. Defaults to 0
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+    """
+
+    ZERO_LEVEL_SPEC_DB_VAL = -16.635  # Log-Melspectrogram value for zero signal
+    NORM_MODES = ["pre_norm", "post_norm"]
+    RTTM_MODES = ["mask", "drop"]
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'features': NeuralType(('B', 'D', 'T'), AcousticEncodedRepresentation()),
+            'feature_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        parser: Union[str, Callable],
+        normalize: Optional[str] = "post_norm",
+        normalize_type: Union[str, dict] = "per_feature",
+        use_rttm: bool = False,
+        rttm_mode: str = "mask",
+        feat_min_len: int = 4,
+        feat_mask_val: Optional[float] = None,
+        frame_unit_time_secs: float = 0.01,
+        sample_rate: Optional[int] = 16000,
+        augmentor: 'nemo.collections.asr.parts.perturb.FeatureAugmentor' = None,
+        max_duration: Optional[int] = None,
+        min_duration: Optional[int] = None,
+        max_utts: int = 0,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+    ):
+        if type(manifest_filepath) == str:
+            manifest_filepath = manifest_filepath.split(",")
+
+        self.sample_rate = sample_rate
+        self.normalize = normalize
+        self.normalize_type = normalize_type
+        self.use_rttm = use_rttm
+        self.rttm_mode = rttm_mode
+        if self.use_rttm and self.rttm_mode not in self.RTTM_MODES:
+            raise ValueError(f"`rttm_mode` must be one of {self.RTTM_MODES}, got `{rttm_mode}` instead")
+
+        self.feat_min_len = feat_min_len
+        if feat_mask_val is not None:
+            self.feat_mask_val = feat_mask_val
+        elif normalize == "pre_norm":
+            self.feat_mask_val = 0.0  # similar to SpectralAugmentation
+        else:
+            self.feat_mask_val = self.ZERO_LEVEL_SPEC_DB_VAL
+
+        if normalize is not None and normalize not in self.NORM_MODES:
+            raise ValueError(f"`normalize` must be one of {self.NORM_MODES}, got `{normalize}` instead")
+
+        self.frame_unit_time_secs = frame_unit_time_secs
+
+        self.manifest_processor = ASRFeatureManifestProcessor(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+        )
+        self.featurizer = ExternalFeatureLoader(augmentor=augmentor)
+        self.trim = trim
+        self.return_sample_id = return_sample_id
+        self.channel_selector = channel_selector
+
+    def get_manifest_sample(self, sample_id):
+        return self.manifest_processor.collection[sample_id]
+
+    def __getitem__(self, index):
+        sample = self.manifest_processor.collection[index]
+        offset = sample.offset
+
+        if offset is None:
+            offset = 0
+
+        features = self.featurizer.process(sample.feature_file)
+
+        f, fl = features, torch.tensor(features.shape[1]).long()
+
+        t, tl = self.manifest_processor.process_text_by_sample(sample=sample)
+
+        # Feature normalization
+        if self.normalize is None:
+            if self.use_rttm and sample.rttm_file:
+                f = self.process_features_with_rttm(f, offset, sample.rttm_file, self.feat_mask_val)
+        elif self.normalize == "post_norm":
+            # (Optional) Masking based on RTTM file
+            if self.use_rttm and sample.rttm_file:
+                f = self.process_features_with_rttm(f, offset, sample.rttm_file, self.feat_mask_val)
+
+            f = self.normalize_feature(f)
+        else:  # pre-norm
+            f = self.normalize_feature(f)
+            # (Optional) Masking based on RTTM file
+            if self.use_rttm and sample.rttm_file:
+                f = self.process_features_with_rttm(f, offset, sample.rttm_file, self.feat_mask_val)
+
+        if self.return_sample_id:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long(), index
+        else:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long()
+
+        return output
+
+    def process_features_with_rttm(self, features, offset, rttm_file, mask_val):
+        segments = load_speech_segments_from_rttm(rttm_file)
+        new_features = features.clone()
+        sid, fid = 0, 0
+        for i in range(features.size(1)):
+            t = offset + i * self.frame_unit_time_secs
+            while sid < len(segments) - 1 and segments[sid][1] < t:
+                sid += 1
+            if segments[sid][1] == 0 or t < segments[sid][0] or t > segments[sid][1]:
+                # not in speech segment
+                if self.rttm_mode == "drop":
+                    # drop the frame
+                    continue
+                else:
+                    # mask the frame with specified value
+                    new_features[:, i] = mask_val
+                    fid += 1
+            else:
+                # in speech segment
+                new_features[:, fid] = features[:, i]
+                fid += 1
+
+        if fid < self.feat_min_len and self.rttm_mode == "drop":
+            new_features[:, : self.feat_min_len] = mask_val
+            return new_features[:, : self.feat_min_len]
+        return new_features[:, :fid]
+
+    def __len__(self):
+        return len(self.manifest_processor.collection)
+
+    def _collate_fn(self, batch):
+        return _audio_feature_collate_fn(
+            batch, feat_pad_val=self.feat_mask_val, label_pad_id=self.manifest_processor.pad_id
+        )
+
+    def normalize_feature(self, feat):
+        """
+        Args:
+            feat: feature tensor of shape [M, T]
+        """
+        feat = feat.unsqueeze(0)  # add batch dim
+        feat, _, _ = normalize_batch(feat, torch.tensor([feat.size(-1)]), self.normalize_type)
+        return feat.squeeze(0)  # delete batch dim
+
+
+class FeatureToCharDataset(_FeatureTextDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio feature
+    files, transcripts, durations (in seconds) and optional RTTM files. Each new line is a
+    different sample. Example below:
+    {"feature_filepath": "/path/to/audio_feature.pt", "text_filepath":
+    "/path/to/audio.txt", "duration": 23.147, "rttm_filepath": "/path/to/audio_rttm.rttm",}
+    ...
+    {"feature_filepath": "/path/to/audio_feature.pt", "text": "the
+    transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    Args:
+        manifest_filepath (str): Path to manifest json as described above. Can
+            be comma-separated paths.
+        labels (str): String containing all the possible characters to map to
+        normalize (str): how to normalize feature, must be one of [None, "post_norm", "pre_norm"]
+        normalize_type (Union[str, dict]): how to normalize feature, see `nemo.collections.asr.parts.preprocessing.features.normalize_batch`
+        use_rttm (bool): whether to use RTTM files if there is any, default to False
+        rttm_mode (str): how to use RTTM files, must be one of ['mask', 'drop'], default to 'mask'
+        feat_min_len (int): minimum length of feature, default to 4
+        feat_mask_val (Optional[float]): value used to mask features with RTTM files, default to None to use zero mel-spectralgram
+        frame_unit_time_secs: time in seconds for each frame
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include
+            in dataset
+        max_utts: Limit number of utterances
+        blank_index: blank character index, default = -1
+        unk_index: unk_character index, default = -1
+        bos_id: Id of beginning of sequence symbol to append if not None
+        eos_id: Id of end of sequence symbol to append if not None
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        labels: Union[str, List[str]],
+        normalize: Optional[str] = "post_norm",
+        normalize_type: Union[str, dict] = "per_feature",
+        use_rttm: bool = False,
+        rttm_mode: str = "mask",
+        feat_min_len: int = 4,
+        feat_mask_val: Optional[float] = None,
+        frame_unit_time_secs: float = 0.01,
+        sample_rate: Optional[int] = 16000,
+        augmentor: 'nemo.collections.asr.parts.perturb.FeatureAugmentor' = None,
+        max_duration: Optional[int] = None,
+        min_duration: Optional[int] = None,
+        max_utts: int = 0,
+        blank_index: int = -1,
+        unk_index: int = -1,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        parser: Union[str, Callable] = 'en',
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+    ):
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            parser=parser,
+            normalize=normalize,
+            normalize_type=normalize_type,
+            use_rttm=use_rttm,
+            rttm_mode=rttm_mode,
+            feat_min_len=feat_min_len,
+            feat_mask_val=feat_mask_val,
+            frame_unit_time_secs=frame_unit_time_secs,
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+        )
+
+
+class FeatureToBPEDataset(_FeatureTextDataset):
+    """
+    Dataset that loads tensors via a json file containing paths to audio feature
+    files, transcripts, durations (in seconds) and optional RTTM files. Each new line is a different sample.
+    Example below:
+    {"audio_filepath": "/path/to/audio.wav", "text_filepath":
+    "/path/to/audio.txt", "duration": 23.147, "rttm_filepath": "/path/to/audio_rttm.rttm",}
+    ...
+    {"audio_filepath": "/path/to/audio.wav", "text": "the
+    transcription", "offset": 301.75, "duration": 0.82, "utt":
+    "utterance_id", "ctm_utt": "en_4156", "side": "A"}
+
+    In practice, the dataset and manifest used for character encoding and byte pair encoding
+    are exactly the same. The only difference lies in how the dataset tokenizes the text in
+    the manifest.
+
+    Args:
+        manifest_filepath (str): Path to manifest json as described above. Can
+            be comma-separated paths.
+        tokenizer: A subclass of the Tokenizer wrapper found in the common collection,
+            nemo.collections.common.tokenizers.TokenizerSpec. ASR Models support a subset of
+            all available tokenizers.
+        normalize (str): how to normalize feature, must be one of [None, "post_norm", "pre_norm"]
+        normalize_type (Union[str, dict]): how to normalize feature, see `nemo.collections.asr.parts.preprocessing.features.normalize_batch`
+        use_rttm (bool): whether to use RTTM files if there is any, default to False
+        rttm_mode (str): how to use RTTM files, must be one of ['mask', 'drop'], default to 'mask'
+        feat_min_len (int): minimum length of feature, default to 4
+        feat_mask_val (Optional[float]): value used to mask features with RTTM files, default to None to use zero mel-spectralgram
+        frame_unit_time_secs: time in seconds for each frame
+        sample_rate (int): Sample rate to resample loaded audio to
+        int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
+        augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor
+            object used to augment loaded audio
+        max_duration: If audio exceeds this length, do not include in dataset
+        min_duration: If audio is less than this length, do not include
+            in dataset
+        max_utts: Limit number of utterances
+        trim: Whether to trim silence segments
+        use_start_end_token: Boolean which dictates whether to add [BOS] and [EOS]
+            tokens to beginning and ending of speech respectively.
+        return_sample_id (bool): whether to return the sample_id as a part of each sample
+        channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: str,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        normalize: Optional[str] = "post_norm",
+        normalize_type: Union[str, dict] = "per_feature",
+        use_rttm: bool = False,
+        rttm_mode: str = "mask",
+        feat_min_len: int = 4,
+        feat_mask_val: Optional[float] = None,
+        frame_unit_time_secs: float = 0.01,
+        sample_rate: Optional[int] = 16000,
+        augmentor: 'nemo.collections.asr.parts.perturb.FeatureAugmentor' = None,
+        max_duration: Optional[int] = None,
+        min_duration: Optional[int] = None,
+        max_utts: int = 0,
+        use_start_end_token: bool = True,
+        trim: bool = False,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+    ):
+        if use_start_end_token and hasattr(tokenizer, "bos_id") and tokenizer.bos_id > 0:
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, "eos_id") and tokenizer.eos_id > 0:
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, "pad_id") and tokenizer.pad_id > 0:
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                if isinstance(tokenizer, tokenizers.aggregate_tokenizer.AggregateTokenizer):
+                    self.is_aggregate = True
+                else:
+                    self.is_aggregate = False
+                self._tokenizer = tokenizer
+
+            def __call__(self, *args):
+                if isinstance(args[0], List) and self.is_aggregate:
+                    t = []
+                    for span in args[0]:
+                        t.extend(self._tokenizer.text_to_ids(span['str'], span['lang']))
+                    return t
+
+                t = self._tokenizer.text_to_ids(*args)
+                return t
+
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            parser=TokenizerWrapper(tokenizer),
+            normalize=normalize,
+            normalize_type=normalize_type,
+            use_rttm=use_rttm,
+            rttm_mode=rttm_mode,
+            feat_min_len=feat_min_len,
+            feat_mask_val=feat_mask_val,
+            frame_unit_time_secs=frame_unit_time_secs,
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            max_duration=max_duration,
+            min_duration=min_duration,
+            max_utts=max_utts,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+        )

nemo/collections/asr/data/feature_to_text_dataset.py

@@ -0,0 +1,94 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Optional
+
+from nemo.collections.asr.data.feature_to_text import FeatureToBPEDataset, FeatureToCharDataset
+from nemo.utils import logging
+
+
+def get_char_dataset(config: dict, augmentor: Optional['FeatureAugmentor'] = None) -> FeatureToCharDataset:
+    """
+    Instantiates a Character Encoding based FeatureToCharDataset.
+
+    Args:
+        config: Config of the FeatureToCharDataset.
+        augmentor: Optional AudioAugmentor object for augmentations on audio data.
+
+    Returns:
+        An instance of FeatureToCharDataset.
+    """
+    if 'labels' not in config:
+        logging.warning(f"dataset does not have explicitly defined labels")
+
+    dataset = FeatureToCharDataset(
+        manifest_filepath=config['manifest_filepath'],
+        labels=config.get('labels', None),
+        normalize=config.get('normalize', 'post_norm'),
+        normalize_type=config.get('normalize_type', 'per_feature'),
+        use_rttm=config.get('use_rttm', False),
+        rttm_mode=config.get('rttm_mode', 'mask'),
+        feat_min_len=config.get('feat_min_len', 4),
+        feat_mask_val=config.get('feat_mask_val', None),
+        frame_unit_time_secs=config.get('frame_unit_time_secs', 0.01),
+        sample_rate=config.get('sample_rate', 16000),
+        augmentor=augmentor,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        max_utts=config.get('max_utts', 0),
+        blank_index=config.get('blank_index', -1),
+        unk_index=config.get('unk_index', -1),
+        trim=config.get('trim_silence', False),
+        parser=config.get('parser', 'en'),
+        return_sample_id=config.get('return_sample_id', False),
+        channel_selector=config.get('channel_selector', None),
+    )
+    return dataset
+
+
+def get_bpe_dataset(
+    config: dict, tokenizer: 'TokenizerSpec', augmentor: Optional['FeatureAugmentor'] = None
+) -> FeatureToBPEDataset:
+    """
+    Instantiates a Byte Pair Encoding / Word Piece Encoding based FeatureoToBPEDataset.
+
+    Args:
+        config: Config of the FeatureToBPEDataset.
+        tokenizer: An instance of a TokenizerSpec object.
+        augmentor: Optional FeatureAugmentor object for augmentations on audio features.
+
+    Returns:
+        An instance of FeatureToBPEDataset.
+    """
+    dataset = FeatureToBPEDataset(
+        manifest_filepath=config['manifest_filepath'],
+        tokenizer=tokenizer,
+        normalize=config.get('normalize', 'post_norm'),
+        normalize_type=config.get('normalize_type', 'per_feature'),
+        use_rttm=config.get('use_rttm', False),
+        rttm_mode=config.get('rttm_mode', 'mask'),
+        feat_min_len=config.get('feat_min_len', 4),
+        feat_mask_val=config.get('feat_mask_val', None),
+        frame_unit_time_secs=config.get('frame_unit_time_secs', 0.01),
+        sample_rate=config.get('sample_rate', 16000),
+        augmentor=augmentor,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        max_utts=config.get('max_utts', 0),
+        trim=config.get('trim_silence', False),
+        use_start_end_token=config.get('use_start_end_token', True),
+        return_sample_id=config.get('return_sample_id', False),
+        channel_selector=config.get('channel_selector', None),
+    )
+    return dataset

nemo/collections/asr/data/huggingface/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.

nemo/collections/asr/data/huggingface/hf_audio_to_text.py

@@ -0,0 +1,694 @@
+# Copyright (c) 2023, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+import datasets as hf_datasets
+import torch
+from datasets import concatenate_datasets
+from datasets.distributed import split_dataset_by_node
+from omegaconf import DictConfig, ListConfig, open_dict
+
+from nemo.collections.asr.data.audio_to_text import _speech_collate_fn
+from nemo.collections.asr.parts.preprocessing.perturb import AudioAugmentor
+from nemo.collections.asr.parts.preprocessing.segment import AudioSegment, ChannelSelectorType
+from nemo.collections.common import tokenizers
+from nemo.collections.common.parts.preprocessing import parsers
+from nemo.core.classes import Dataset, IterableDataset
+from nemo.core.neural_types import AudioSignal, LabelsType, LengthsType, NeuralType
+from nemo.utils import logging
+
+
+class HFTextProcessor:
+    """
+    Text processor for huggingface datasets, mimicing the behavior of
+    `nemo.collections.asr.data.audio_to_text.ASRManifestProcessor`.
+    Basic text cleaning is also supported.
+    Args:
+        parser: Str for a language specific preprocessor or a callable.
+        bos_id: BOS token id to add to the beginning of the transcript.
+        eos_id: EOS token id to add to the end of the transcript.
+        pad_id: PAD token id to pad transcripts to the same length.
+        normalize_text: If true, normalizes text in HFTextProcessor
+        symbols_to_keep: If not None, only keeps symbols in this list when normalizing text
+    """
+
+    def __init__(
+        self,
+        parser: Union[str, Callable],
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str | List[str]] = None,
+    ):
+        self.parser = parser
+        self.eos_id = eos_id
+        self.bos_id = bos_id
+        self.pad_id = pad_id
+        self.normalize_text = normalize_text
+        self.symbols_to_keep = [x for x in symbols_to_keep] if symbols_to_keep is not None else []
+
+    def process_text(self, text: str, lang: Optional[str] = None) -> List[int]:
+
+        if self.normalize_text:
+            text = text.lower()
+            # only keep alphanumeric characters, spaces and symbols defined in self.symbols_to_keep
+            text = ''.join([c for c in text if c.isalnum() or c.isspace() or c in self.symbols_to_keep])
+
+        if hasattr(self.parser, "is_aggregate") and self.parser.is_aggregate and isinstance(text, str):
+            if lang is not None:
+                text_tokens = self.parser(text, lang)
+            # for future use if want to add language bypass to audio_to_text classes
+            # elif hasattr(parser, "lang") and parser.lang is not None:
+            #    text_tokens = parser(text, parser.lang)
+            else:
+                raise ValueError("lang required in manifest when using aggregate tokenizers")
+        else:
+            text_tokens = self.parser(text)
+        text_tokens_length = len(text_tokens)
+        if self.bos_id is not None:
+            text_tokens = [self.bos_id] + text_tokens
+            text_tokens_length += 1
+        if self.eos_id is not None:
+            text_tokens = text_tokens + [self.eos_id]
+            text_tokens_length += 1
+        return text_tokens, text_tokens_length
+
+
+def get_nested_dict_value(dictionary: dict, key: str):
+    """
+    the key should be a string of nested keys separated by `.`, e.g. `key1.key2.key3`,
+    then the returned value will be `dictionary[key1][key2][key3]`
+    """
+    nested_keys = key.split(".")
+    result = dictionary
+    for k in nested_keys:
+        if k not in result:
+            raise KeyError(
+                f"Key `{key}` not found in [{result.keys()}], target is {nested_keys}, input is {dictionary}"
+            )
+        result = result[k]
+    return result
+
+
+class _HFAudioTextDataset(Dataset):
+    """
+    A Dataset wrapper that loads from HuggingFace datasets and converts to NeMo compatible format.
+    Args:
+        audio_key: key to access audio data from the dataset
+        text_key: key to access text data from the dataset
+        sample_rate_key: key to access sample rate data from the dataset
+        hf_data_cfg: HuggingFace dataset config, all params in this config will be passed to `hf_datasets.load_dataset`
+        parser: Str for a language specific preprocessor or a callable.
+        augmentor: An instance of `nemo.collections.asr.parts.perturb.AudioAugmentor` to apply on audio.
+        trim: If true, trims silence using `nemo.collections.asr.parts.preprocessing.segment.AudioSegment`
+        bos_id: BOS token id to add to the beginning of the transcript.
+        eos_id: EOS token id to add to the end of the transcript.
+        pad_id: PAD token id to pad transcripts to the same length.
+        return_sample_id: If true, returns sample id from the dataset.
+        channel_selector: ChannelSelectorType, which channel(s) to use for audio.
+        normalize_db: Target RMS value for audio normalization.
+        ref_channel: Reference channel for normalization.
+        id_key: key to access sample id from the dataset
+        normalize_text: If true, normalizes text in HFTextProcessor
+        symbols_to_keep: If not None, only keeps symbols in this list when normalizing text
+    """
+
+    def __init__(
+        self,
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: Union[DictConfig, ListConfig],
+        parser: Union[str, Callable],
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        normalize_db: Optional[float] = None,
+        ref_channel: Optional[int] = None,
+        id_key: Optional[str] = None,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self.audio_key = audio_key
+        self.text_key = text_key
+        self.sample_rate_key = sample_rate_key
+        self.id_key = id_key
+        self.sample_rate = sample_rate
+        self.augmentor = augmentor if augmentor is not None else AudioAugmentor()
+        self.trim = trim
+        self.return_sample_id = return_sample_id
+        self.channel_selector = channel_selector
+        self.normalize_db = normalize_db
+        self.ref_channel = ref_channel
+
+        self.text_processor = HFTextProcessor(parser, bos_id, eos_id, pad_id, normalize_text, symbols_to_keep)
+
+        data_config_list = [hf_data_cfg] if isinstance(hf_data_cfg, DictConfig) else hf_data_cfg
+        dataset_list = []
+        for data_cfg in data_config_list:
+            with open_dict(data_cfg):
+                if "streaming" in data_cfg and data_cfg.streaming:
+                    logging.warning(
+                        "streaming must be False for random access dataset, but you use streaming=True. Forcing streaming=False"
+                    )
+                data_cfg.streaming = False
+            logging.info(f"Loading HuggingFace Dataset with cfg: {data_cfg}")
+            dataset_list.append(hf_datasets.load_dataset(**data_cfg))
+            logging.info(f"Dataset loaded with {len(dataset_list[-1])} samples")
+        self.dataset = concatenate_datasets(dataset_list)
+
+        logging.info(f"Total number of samples loaded: {len(self.dataset)}")
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, index) -> Tuple:
+        item = self.dataset[index]
+
+        audio_array = get_nested_dict_value(item, self.audio_key)
+        origin_sr = get_nested_dict_value(item, self.sample_rate_key)
+        audio_segment = AudioSegment(
+            samples=audio_array,
+            sample_rate=origin_sr,
+            target_sr=self.sample_rate,
+            trim=self.trim,
+            channel_selector=self.channel_selector,
+            normalize_db=self.normalize_db,
+            ref_channel=self.ref_channel,
+        )
+        self.augmentor.perturb(audio_segment)
+        f = torch.tensor(audio_segment.samples, dtype=torch.float)
+        fl = torch.tensor(f.shape[0], dtype=torch.long)
+
+        text = get_nested_dict_value(item, self.text_key)
+        t, tl = self.text_processor.process_text(text)
+
+        index = get_nested_dict_value(item, self.id_key) if self.id_key else index
+        if self.return_sample_id:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long(), index
+        else:
+            output = f, fl, torch.tensor(t).long(), torch.tensor(tl).long()
+
+        return output
+
+    def _collate_fn(self, batch):
+        return _speech_collate_fn(batch, pad_id=self.text_processor.pad_id)
+
+
+class HFAudioToCharDataset(_HFAudioTextDataset):
+    """
+    Wrapper class for loading HuggingFace dataset for a char-based ASR model
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: DictConfig,
+        labels: List[str],
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        normalize_db: Optional[float] = None,
+        ref_channel: Optional[int] = None,
+        parser: Union[str, Callable] = 'en',
+        blank_index: int = -1,
+        unk_index: int = -1,
+        normalize: bool = True,
+        id_key: Optional[str] = None,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ):
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            audio_key=audio_key,
+            text_key=text_key,
+            sample_rate_key=sample_rate_key,
+            hf_data_cfg=hf_data_cfg,
+            parser=parser,
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+            normalize_db=normalize_db,
+            ref_channel=ref_channel,
+            id_key=id_key,
+            normalize_text=normalize_text,
+            symbols_to_keep=symbols_to_keep,
+        )
+
+
+class HFAudioToBPEDataset(_HFAudioTextDataset):
+    """
+    Wrapper class for loading a HuggingFace dataset for a BPE-based ASR model
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: DictConfig,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        normalize_db: Optional[float] = None,
+        ref_channel: Optional[int] = None,
+        use_start_end_token: bool = True,
+        id_key: Optional[str] = None,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ):
+        if use_start_end_token and hasattr(tokenizer, "bos_id") and tokenizer.bos_id > 0:
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, "eos_id") and tokenizer.eos_id > 0:
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, "pad_id") and tokenizer.pad_id > 0:
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                if isinstance(tokenizer, tokenizers.aggregate_tokenizer.AggregateTokenizer):
+                    self.is_aggregate = True
+                else:
+                    self.is_aggregate = False
+                self._tokenizer = tokenizer
+
+            def __call__(self, *args):
+                if isinstance(args[0], List) and self.is_aggregate:
+                    t = []
+                    for span in args[0]:
+                        t.extend(self._tokenizer.text_to_ids(span['str'], span['lang']))
+                    return t
+
+                t = self._tokenizer.text_to_ids(*args)
+                return t
+
+        super().__init__(
+            audio_key=audio_key,
+            text_key=text_key,
+            sample_rate_key=sample_rate_key,
+            hf_data_cfg=hf_data_cfg,
+            parser=TokenizerWrapper(tokenizer),
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            channel_selector=channel_selector,
+            normalize_db=normalize_db,
+            ref_channel=ref_channel,
+            id_key=id_key,
+            normalize_text=normalize_text,
+            symbols_to_keep=symbols_to_keep,
+        )
+
+
+class _HFIterableAudioTextDataset(IterableDataset):
+    """
+    Wrapper class for loading HuggingFace IterableDataset and converts to NeMo compatible format.
+    Args:
+        audio_key: key to access audio data from the dataset
+        text_key: key to access text data from the dataset
+        sample_rate_key: key to access sample rate data from the dataset
+        hf_data_cfg: HuggingFace dataset config, all params in this config will be passed to `hf_datasets.load_dataset`
+        parser: Str for a language specific preprocessor or a callable.
+        augmentor: An instance of `nemo.collections.asr.parts.perturb.AudioAugmentor` to apply on audio.
+        trim: If true, trims silence using `nemo.collections.asr.parts.preprocessing.segment.AudioSegment`
+        bos_id: BOS token id to add to the beginning of the transcript.
+        eos_id: EOS token id to add to the end of the transcript.
+        pad_id: PAD token id to pad transcripts to the same length.
+        return_sample_id: If true, returns sample id from the dataset.
+        channel_selector: ChannelSelectorType, which channel(s) to use for audio.
+        normalize_db: Target RMS value for audio normalization.
+        ref_channel: Reference channel for normalization.
+        id_key: key to access sample id from the dataset
+        global_rank: global rank of the current worker
+        world_size: total number of workers
+        shuffle_n: buffer size for shuffling
+        shuffle_seed: seed for shuffling
+        normalize_text: If true, normalizes text in HFTextProcessor
+        symbols_to_keep: If not None, only keeps symbols in this list when normalizing text
+    """
+
+    def __init__(
+        self,
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: Union[DictConfig, ListConfig],
+        parser: Union[str, Callable],
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        bos_id: Optional[int] = None,
+        eos_id: Optional[int] = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        channel_selector: Optional[ChannelSelectorType] = None,
+        normalize_db: Optional[float] = None,
+        ref_channel: Optional[int] = None,
+        id_key: Optional[str] = None,
+        global_rank: int = 0,
+        world_size: int = 0,
+        shuffle_n: int = 0,
+        shuffle_seed: Optional[int] = None,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        if return_sample_id and id_key is None:
+            raise ValueError("return_sample_id is True, but id_key is None")
+
+        self.audio_key = audio_key
+        self.text_key = text_key
+        self.sample_rate_key = sample_rate_key
+        self.id_key = id_key
+        self.sample_rate = sample_rate
+        self.augmentor = augmentor if augmentor is not None else AudioAugmentor()
+        self.trim = trim
+        self.return_sample_id = return_sample_id
+        self.channel_selector = channel_selector
+        self.normalize_db = normalize_db
+        self.ref_channel = ref_channel
+
+        self.text_processor = HFTextProcessor(parser, bos_id, eos_id, pad_id, normalize_text, symbols_to_keep)
+
+        data_config_list = [hf_data_cfg] if isinstance(hf_data_cfg, DictConfig) else hf_data_cfg
+        dataset_list = []
+        for data_cfg in data_config_list:
+            with open_dict(data_cfg):
+                if "streaming" in data_cfg and not data_cfg.streaming:
+                    logging.warning(
+                        "streaming must be True for streaming dataset, but you use streaming=False. Forcing streaming=True"
+                    )
+                # streaming must be True for iterable dataset
+                data_cfg.streaming = True
+            logging.info(f"Streaming HuggingFace IterableDataset with cfg: {data_cfg}")
+            dataset_list.append(hf_datasets.load_dataset(**data_cfg))
+
+        self.dataset = concatenate_datasets(dataset_list)
+        logging.info(f"Total number of samples cannot be extracted from HF streaming dataset")
+
+        if shuffle_n > 0:
+            self.dataset = self.dataset.shuffle(seed=shuffle_seed, buffer_size=shuffle_n)
+
+        self.dataset = split_dataset_by_node(self.dataset, global_rank, world_size)
+        self.dataset = self.dataset.map(self._build_sample)
+
+    def __len__(self):
+        raise NotImplementedError(
+            f"len() is not supported for {self.__class__.__name__}. Please set `trainer.max_steps` to explicitly set the number of steps to train for."
+        )
+
+    def __iter__(self):
+        return self.dataset.__iter__()
+
+    def _collate_fn(self, batch):
+        a_signal = [b['audio_signal'] for b in batch]
+        a_sig_length = [b['a_sig_length'] for b in batch]
+        transcripts = [b['transcripts'] for b in batch]
+        transcript_length = [b['transcript_length'] for b in batch]
+        if self.return_sample_id:
+            sample_id = [b['sample_id'] for b in batch]
+            batch_list = list(zip(a_signal, a_sig_length, transcripts, transcript_length, sample_id))
+        else:
+            batch_list = list(zip(a_signal, a_sig_length, transcripts, transcript_length))
+
+        return _speech_collate_fn(batch_list, pad_id=self.text_processor.pad_id)
+
+    def _build_sample(self, sample):
+        audio_array = get_nested_dict_value(sample, self.audio_key)
+        origin_sr = get_nested_dict_value(sample, self.sample_rate_key)
+        audio_segment = AudioSegment(
+            samples=audio_array,
+            sample_rate=origin_sr,
+            target_sr=self.sample_rate,
+            trim=self.trim,
+            channel_selector=self.channel_selector,
+            normalize_db=self.normalize_db,
+            ref_channel=self.ref_channel,
+        )
+        self.augmentor.perturb(audio_segment)
+        f = torch.tensor(audio_segment.samples, dtype=torch.float)
+        fl = torch.tensor(f.shape[0], dtype=torch.long)
+
+        text = get_nested_dict_value(sample, self.text_key)
+        t, tl = self.text_processor.process_text(text)
+
+        output = {
+            'audio_signal': f,
+            'a_sig_length': fl,
+            'transcripts': torch.tensor(t).long(),
+            'transcript_length': torch.tensor(tl).long(),
+        }
+
+        if self.return_sample_id:
+            output['sample_id'] = get_nested_dict_value(sample, self.id_key)
+        return output
+
+
+class HFIterableAudioToCharDataset(_HFIterableAudioTextDataset):
+    """
+    Wrapper class for loading HuggingFace IterableDataset for a char-based ASR model
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        labels: List[str],
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: DictConfig,
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        bos_id: int | None = None,
+        eos_id: int | None = None,
+        pad_id: int = 0,
+        return_sample_id: bool = False,
+        id_key: str | None = None,
+        channel_selector: ChannelSelectorType | None = None,
+        normalize_db: float | None = None,
+        ref_channel: int | None = None,
+        global_rank: int = 0,
+        world_size: int = 0,
+        shuffle_n: int = 0,
+        shuffle_seed: Optional[int] = None,
+        parser: Union[str, Callable] = 'en',
+        blank_index: int = -1,
+        unk_index: int = -1,
+        normalize: bool = True,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ) -> None:
+        self.labels = labels
+
+        parser = parsers.make_parser(
+            labels=labels, name=parser, unk_id=unk_index, blank_id=blank_index, do_normalize=normalize
+        )
+
+        super().__init__(
+            audio_key=audio_key,
+            text_key=text_key,
+            sample_rate_key=sample_rate_key,
+            hf_data_cfg=hf_data_cfg,
+            parser=parser,
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            id_key=id_key,
+            channel_selector=channel_selector,
+            normalize_db=normalize_db,
+            ref_channel=ref_channel,
+            global_rank=global_rank,
+            world_size=world_size,
+            shuffle_n=shuffle_n,
+            shuffle_seed=shuffle_seed,
+            normalize_text=normalize_text,
+            symbols_to_keep=symbols_to_keep,
+        )
+
+
+class HFIterableAudioToBPEDataset(_HFIterableAudioTextDataset):
+    """
+    Wrapper class for loading HuggingFace IterableDataset for a BPE-based ASR model
+    """
+
+    @property
+    def output_types(self) -> Optional[Dict[str, NeuralType]]:
+        """Returns definitions of module output ports."""
+        return {
+            'audio_signal': NeuralType(('B', 'T'), AudioSignal()),
+            'a_sig_length': NeuralType(tuple('B'), LengthsType()),
+            'transcripts': NeuralType(('B', 'T'), LabelsType()),
+            'transcript_length': NeuralType(tuple('B'), LengthsType()),
+            'sample_id': NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        audio_key: str,
+        text_key: str,
+        sample_rate_key: str,
+        hf_data_cfg: DictConfig,
+        tokenizer: 'nemo.collections.common.tokenizers.TokenizerSpec',
+        sample_rate: int,
+        augmentor: 'nemo.collections.asr.parts.perturb.AudioAugmentor' = None,
+        trim: bool = False,
+        return_sample_id: bool = False,
+        id_key: str | None = None,
+        channel_selector: ChannelSelectorType | None = None,
+        normalize_db: float | None = None,
+        ref_channel: int | None = None,
+        global_rank: int = 0,
+        world_size: int = 0,
+        shuffle_n: int = 0,
+        shuffle_seed: Optional[int] = None,
+        use_start_end_token: bool = True,
+        normalize_text: bool = False,
+        symbols_to_keep: Optional[str] = None,
+    ) -> None:
+
+        if use_start_end_token and hasattr(tokenizer, "bos_id") and tokenizer.bos_id > 0:
+            bos_id = tokenizer.bos_id
+        else:
+            bos_id = None
+
+        if use_start_end_token and hasattr(tokenizer, "eos_id") and tokenizer.eos_id > 0:
+            eos_id = tokenizer.eos_id
+        else:
+            eos_id = None
+
+        if hasattr(tokenizer, "pad_id") and tokenizer.pad_id > 0:
+            pad_id = tokenizer.pad_id
+        else:
+            pad_id = 0
+
+        class TokenizerWrapper:
+            def __init__(self, tokenizer):
+                if isinstance(tokenizer, tokenizers.aggregate_tokenizer.AggregateTokenizer):
+                    self.is_aggregate = True
+                else:
+                    self.is_aggregate = False
+                self._tokenizer = tokenizer
+
+            def __call__(self, *args):
+                if isinstance(args[0], List) and self.is_aggregate:
+                    t = []
+                    for span in args[0]:
+                        t.extend(self._tokenizer.text_to_ids(span['str'], span['lang']))
+                    return t
+
+                t = self._tokenizer.text_to_ids(*args)
+                return t
+
+        super().__init__(
+            audio_key=audio_key,
+            text_key=text_key,
+            sample_rate_key=sample_rate_key,
+            hf_data_cfg=hf_data_cfg,
+            parser=TokenizerWrapper(tokenizer),
+            sample_rate=sample_rate,
+            augmentor=augmentor,
+            trim=trim,
+            bos_id=bos_id,
+            eos_id=eos_id,
+            pad_id=pad_id,
+            return_sample_id=return_sample_id,
+            id_key=id_key,
+            channel_selector=channel_selector,
+            normalize_db=normalize_db,
+            ref_channel=ref_channel,
+            global_rank=global_rank,
+            world_size=world_size,
+            shuffle_n=shuffle_n,
+            shuffle_seed=shuffle_seed,
+            normalize_text=normalize_text,
+            symbols_to_keep=symbols_to_keep,
+        )

nemo/collections/asr/data/huggingface/hf_audio_to_text_dataset.py

@@ -0,0 +1,132 @@
+# Copyright (c) 2023, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from omegaconf import DictConfig
+
+from nemo.collections.asr.data.huggingface.hf_audio_to_text import (
+    HFAudioToBPEDataset,
+    HFAudioToCharDataset,
+    HFIterableAudioToBPEDataset,
+    HFIterableAudioToCharDataset,
+)
+
+
+def get_hf_audio_to_text_bpe_dataset(
+    config: DictConfig, global_rank: int, world_size: int, tokenizer, augmentor=None,
+):
+    if "streaming" in config and config["streaming"]:
+        dataset = HFIterableAudioToBPEDataset(
+            audio_key=config.get('audio_key', 'audio.array'),
+            text_key=config["text_key"],
+            sample_rate_key=config.get('sample_rate_key', 'audio.sampling_rate'),
+            tokenizer=tokenizer,
+            hf_data_cfg=config["hf_data_cfg"],
+            sample_rate=config["sample_rate"],
+            augmentor=augmentor,
+            trim=config.get('trim_silence', False),
+            return_sample_id=config.get('return_sample_id', False),
+            id_key=config.get("id_key", None),
+            channel_selector=config.get('channel_selector', None),
+            normalize_db=config.get('normalize_db', None),
+            ref_channel=config.get('ref_channel', None),
+            global_rank=global_rank,
+            world_size=world_size,
+            shuffle_n=config.get("shuffle_n", 2048),
+            shuffle_seed=config.get("shuffle_seed", None),
+            use_start_end_token=config.get('use_start_end_token', True),
+            normalize_text=config.get('normalize_text', False),
+            symbols_to_keep=config.get('symbols_to_keep', None),
+        )
+    else:
+        dataset = HFAudioToBPEDataset(
+            audio_key=config.get('audio_key', 'audio.array'),
+            text_key=config["text_key"],
+            sample_rate_key=config.get('sample_rate_key', 'audio.sampling_rate'),
+            tokenizer=tokenizer,
+            hf_data_cfg=config["hf_data_cfg"],
+            sample_rate=config["sample_rate"],
+            augmentor=augmentor,
+            trim=config.get('trim_silence', False),
+            return_sample_id=config.get('return_sample_id', False),
+            id_key=config.get("id_key", None),
+            channel_selector=config.get('channel_selector', None),
+            normalize_db=config.get('normalize_db', None),
+            ref_channel=config.get('ref_channel', None),
+            use_start_end_token=config.get('use_start_end_token', True),
+            normalize_text=config.get('normalize_text', False),
+            symbols_to_keep=config.get('symbols_to_keep', None),
+        )
+
+    return dataset
+
+
+def get_hf_audio_to_text_char_dataset(
+    config: DictConfig, global_rank: int, world_size: int, augmentor=None,
+):
+    if "streaming" in config and config["streaming"]:
+        dataset = HFIterableAudioToCharDataset(
+            labels=config["labels"],
+            audio_key=config.get('audio_key', 'audio.array'),
+            text_key=config["text_key"],
+            sample_rate_key=config.get('sample_rate_key', 'audio.sampling_rate'),
+            hf_data_cfg=config["hf_data_cfg"],
+            sample_rate=config["sample_rate"],
+            augmentor=augmentor,
+            trim=config.get('trim_silence', False),
+            return_sample_id=config.get('return_sample_id', False),
+            id_key=config.get("id_key", None),
+            channel_selector=config.get('channel_selector', None),
+            normalize_db=config.get('normalize_db', None),
+            ref_channel=config.get('ref_channel', None),
+            global_rank=global_rank,
+            world_size=world_size,
+            shuffle_n=config.get("shuffle_n", 2048),
+            shuffle_seed=config.get("shuffle_seed", None),
+            parser=config.get("parser", "en"),
+            blank_index=config.get("blank_index", -1),
+            unk_index=config.get("unk_index", -1),
+            normalize=config.get("normalize", False),
+            normalize_text=config.get('normalize_text', False),
+            symbols_to_keep=config.get('symbols_to_keep', None),
+            pad_id=config.get('pad_id', 0),
+            bos_id=config.get('bos_id', None),
+            eos_id=config.get('eos_id', None),
+        )
+    else:
+        dataset = HFAudioToCharDataset(
+            labels=config["labels"],
+            audio_key=config.get('audio_key', 'audio.array'),
+            text_key=config["text_key"],
+            sample_rate_key=config.get('sample_rate_key', 'audio.sampling_rate'),
+            hf_data_cfg=config["hf_data_cfg"],
+            sample_rate=config["sample_rate"],
+            augmentor=augmentor,
+            trim=config.get('trim_silence', False),
+            bos_id=config.get('bos_id', None),
+            eos_id=config.get('eos_id', None),
+            pad_id=config.get('pad_id', 0),
+            return_sample_id=config.get('return_sample_id', False),
+            id_key=config.get("id_key", None),
+            channel_selector=config.get('channel_selector', None),
+            normalize_db=config.get('normalize_db', None),
+            ref_channel=config.get('ref_channel', None),
+            parser=config.get("parser", "en"),
+            blank_index=config.get("blank_index", -1),
+            unk_index=config.get("unk_index", -1),
+            normalize=config.get("normalize", False),
+            normalize_text=config.get('normalize_text', False),
+            symbols_to_keep=config.get('symbols_to_keep', None),
+        )
+
+    return dataset

nemo/collections/asr/data/ssl_dataset.py

@@ -0,0 +1,705 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 copy
+import io
+import json
+import os
+from dataclasses import dataclass
+from math import isclose
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import torch
+from lhotse.dataset import AudioSamples
+from omegaconf import DictConfig, ListConfig, open_dict
+from torch import Tensor
+
+from nemo.collections.asr.data import audio_to_text, audio_to_text_dataset
+from nemo.collections.asr.parts.preprocessing.perturb import WhiteNoisePerturbation, process_augmentations
+from nemo.collections.asr.parts.preprocessing.segment import AudioSegment
+from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
+from nemo.collections.common.data.dataset import ConcatDataset
+from nemo.collections.common.parts.preprocessing.manifest import get_full_path
+from nemo.core.classes import Serialization
+from nemo.utils import logging
+
+
+@dataclass
+class AudioNoiseItem:
+    sample_id: str | None = None
+    audio: Union[Tensor, None] = None
+    audio_len: Union[Tensor, None] = None
+    noise: Union[Tensor, None] = None
+    noise_len: Union[Tensor, None] = None
+    noisy_audio: Union[Tensor, None] = None
+    noisy_audio_len: Union[Tensor, None] = None
+
+
+@dataclass
+class AudioNoiseBatch:
+    sample_id: list | None = None
+    audio: Union[Tensor, None] = None
+    audio_len: Union[Tensor, None] = None
+    noise: Union[Tensor, None] = None
+    noise_len: Union[Tensor, None] = None
+    noisy_audio: Union[Tensor, None] = None
+    noisy_audio_len: Union[Tensor, None] = None
+
+
+def _parse_manifest_item(line: str, manifest_file: str) -> Dict[str, Any]:
+    """
+    Specialized function to parse the manifest file by ignoring text,
+    such that nemo dataset can save time on tokenizing text.
+    """
+    item = json.loads(line)
+
+    # Audio file
+    if 'audio_filename' in item:
+        item['audio_file'] = item.pop('audio_filename')
+    elif 'audio_filepath' in item:
+        item['audio_file'] = item.pop('audio_filepath')
+    else:
+        raise KeyError(f"No 'audio_filename' or 'audio_filepath' in manifest item: {item}")
+
+    item['audio_file'] = get_full_path(audio_file=item['audio_file'], manifest_file=manifest_file)
+
+    # Duration.
+    if 'duration' not in item:
+        item['duration'] = None
+
+    # dummy text
+    item['text'] = ""
+
+    item = dict(
+        audio_file=item['audio_file'],
+        duration=item['duration'],
+        text=item['text'],
+        offset=item.get('offset', None),
+        speaker=item.get('speaker', None),
+        orig_sr=item.get('orig_sample_rate', None),
+        token_labels=item.get('token_labels', None),
+        lang=item.get('lang', None),
+    )
+    return item
+
+
+def _audio_noise_collate_fn(batch: List[AudioNoiseItem], batch_augmentor: Any = None) -> AudioNoiseBatch:
+    audios = [x.audio for x in batch]
+    audio_lengths = [x.audio_len for x in batch]
+    max_audio_len = max(audio_lengths).item()
+
+    noises = [x.noise for x in batch]
+    noise_lengths = [x.noise_len for x in batch]
+
+    noisy_audios = [x.noisy_audio for x in batch]
+    noisy_audio_lengths = [x.noisy_audio_len for x in batch]
+
+    audio_signal_list = []
+    noise_signal_list = []
+    noisy_audio_signal_list = []
+    for i, audio in enumerate(audios):
+        audio_len = audio.size(0)
+        if audio_len < max_audio_len:
+            pad = (0, max_audio_len - audio_len)
+            audio = torch.nn.functional.pad(audio, pad)
+        audio_signal_list.append(audio)
+
+        noise = noises[i]
+        noise_len = noise.size(0)
+        if noise_len < max_audio_len:
+            pad = (0, max_audio_len - noise_len)
+            noise = torch.nn.functional.pad(noise, pad)
+        noise_signal_list.append(noise[:max_audio_len])
+
+        noisy_audio = noisy_audios[i]
+        noisy_audio_len = noisy_audio.size(0)
+        if noisy_audio_len < max_audio_len:
+            pad = (0, max_audio_len - noisy_audio_len)
+            noisy_audio = torch.nn.functional.pad(noisy_audio, pad)
+        noisy_audio_signal_list.append(noisy_audio[:max_audio_len])
+
+    audio_signal = torch.stack(audio_signal_list).float()
+    audio_lengths = torch.stack(audio_lengths).long()
+    noise_signal = torch.stack(noise_signal_list).float()
+    noise_lengths = torch.stack(noise_lengths).long()
+    noisy_audio_signal = torch.stack(noisy_audio_signal_list).float()
+    noisy_audio_lengths = torch.stack(noisy_audio_lengths).long()
+
+    output = AudioNoiseBatch(
+        audio=audio_signal,
+        audio_len=audio_lengths,
+        noise=noise_signal,
+        noise_len=noise_lengths,
+        noisy_audio=noisy_audio_signal,
+        noisy_audio_len=noisy_audio_lengths,
+    )
+
+    if batch_augmentor is not None:
+        output = batch_augmentor(output)
+
+    return output
+
+
+def load_noise_manifest(noise_manifest: Union[str, ListConfig, None]):
+    """
+    load noise manifest from a single or a list of manifest files
+    """
+    if noise_manifest is None:
+        return []
+
+    if isinstance(noise_manifest, str):
+        noise_manifest = noise_manifest.split(',')
+
+    noise_data = []
+    for manifest in noise_manifest:
+        curr_data = read_manifest(manifest)
+        for i in range(len(curr_data)):
+            curr_data[i]['audio_filepath'] = get_full_path(curr_data[i]['audio_filepath'], manifest)
+        noise_data.extend(curr_data)
+    return noise_data
+
+
+def load_noise_audio(
+    sample: Dict[str, Any],
+    sample_rate: int,
+    max_audio_len: Optional[int] = None,
+    pad_to_max: bool = True,
+    min_white_noise_db: int = -90,
+    max_white_noise_db: int = -46,
+    max_trial: int = 100,
+):
+    """
+    Load noise audio from the manifest item, and apply white noise if the loaded noise audio is empty.
+    Args:
+        sample: a sample from the noise manifest
+        sample_rate: target sample rate to resample the noise audio
+        max_audio_len: the maximum audio length to load
+        pad_to_max: whether to pad the audio to max_audio_len
+        min_white_noise_db: the minimum white noise level in dB
+        max_white_noise_db: the maximum white noise level in dB
+        max_trial: the maximum number of trials to load noise audio before giving up
+    Returns:
+        noise: the loaded noise audio
+        noise_len: the length of the loaded noise audio
+    """
+    max_dur = None if max_audio_len is None else max_audio_len / sample_rate
+    duration = sample.get('duration', None)
+    offset = sample.get('offset', 0.0)
+
+    if max_dur is not None and duration is not None and duration > max_dur:
+        cnt = 0
+        while cnt < max_trial:
+            # randomly sample a segment of the noise
+            offset = np.random.uniform(0, duration - max_dur)
+
+            audio_segment = AudioSegment.from_file(
+                audio_file=sample['audio_filepath'],
+                offset=offset,
+                duration=max_dur,
+                target_sr=sample_rate,
+            )
+
+            if sum(audio_segment.samples) > 0:
+                # break if the segment is not empty
+                break
+            cnt += 1
+    else:
+        audio_segment = AudioSegment.from_file(
+            audio_file=sample['audio_filepath'],
+            offset=offset,
+            duration=duration,
+            target_sr=sample_rate,
+        )
+
+    if sum(audio_segment.samples) == 0:
+        logging.warning(
+            f"Loaded noise audio is empty: {sample}, with sampled offset={offset}, duration={max_dur}. Adding white noise."
+        )
+        WhiteNoisePerturbation(min_level=min_white_noise_db, max_level=max_white_noise_db).perturb(audio_segment)
+
+    noise = torch.tensor(audio_segment.samples, dtype=torch.float)
+    noise_len = torch.tensor(noise.size(0)).long()
+    # pad to max_audio_len if necessary
+    if max_audio_len is not None and pad_to_max:
+        if noise.size(0) < max_audio_len:
+            pad = (0, max_audio_len - noise.size(0))
+            noise = torch.nn.functional.pad(noise, pad)
+        else:
+            noise = noise[:max_audio_len]
+            noise_len = torch.tensor(max_audio_len).long()
+    return noise, noise_len
+
+
+def sample_noise(noise_data: List[Dict], sample_rate: int, max_audio_len: int | None = None, max_trial: int = 20):
+    """
+    Randomly sample noise audio from the noise manifest.
+    Args:
+        noise_data: the noise manifest data
+        sample_rate: target sample rate to resample the noise audio
+        max_audio_len: the maximum audio length to load
+        max_trial: the maximum number of trials to load noise audio before giving up
+    Returns:
+        noise_audio: the sampled noise audio
+        noise_len: the length of the sampled noise audio
+    """
+    cnt = 0
+    noise_audio = torch.zeros(max_audio_len).float()
+    noise_len = torch.tensor(max_audio_len).long()
+    while cnt < max_trial and len(noise_data) > 0:
+        try:
+            noise_sample = noise_data[np.random.randint(len(noise_data))]
+            noise_audio, noise_len = load_noise_audio(noise_sample, sample_rate, max_audio_len)
+            break
+        except Exception as e:
+            logging.warning(f"Error loading noise audio with config {noise_sample} and exception: {e}, retrying.")
+            cnt += 1
+            if cnt == max_trial:
+                logging.warning(f"Failed to load noise audio after {max_trial} attempts, returning zero noise.")
+                return torch.zeros(max_audio_len).float(), torch.tensor(max_audio_len).long()
+    return noise_audio, noise_len
+
+
+def pad_audio(audio: Tensor, min_len: int, pad_audio_mode) -> Tensor:
+    """
+    Pad audio to min_len with the specified mode
+    Args:
+        audio: the input audio tensor
+        min_len: the minimum length to pad to
+        pad_audio_mode: the padding mode, either 'repeat' or 'zero'
+    Returns:
+        audio: the padded audio tensor
+    """
+    allowed_mode = ['repeat', 'zero']
+    if audio.size(0) < min_len:
+        if pad_audio_mode == 'repeat' and audio.size(0) > 0:
+            num_repeats = int(np.ceil(min_len / audio.size(0)))
+            audio = audio.repeat(num_repeats)[:min_len]
+        elif pad_audio_mode == 'zero' or audio.size(0) == 0:
+            audio = torch.nn.functional.pad(audio, (0, min_len - audio.size(0)))
+        else:
+            raise ValueError(f"Unsupported pad_audio_mode: {pad_audio_mode}, must be one of {allowed_mode}")
+    return audio
+
+
+class AudioNoiseDataset(audio_to_text.AudioToCharDataset):
+    @property
+    def output_types(self):
+        # disable type checking for since it doesn't support dataclass
+        return None
+
+    def __init__(
+        self,
+        noise_manifest: str | None = None,
+        batch_augmentor: Any | None = None,
+        min_audio_len_secs: float = 1.0,
+        pad_audio_mode: str = 'repeat',
+        **kwargs,
+    ):
+        # add bos_id=0 to avoid empty text token
+        super().__init__(bos_id=0, manifest_parse_func=_parse_manifest_item, **kwargs)
+        self.noise_manifest = noise_manifest
+        self.batch_augmentor = batch_augmentor
+        self.noise_data = load_noise_manifest(noise_manifest)
+        self.min_audio_len_secs = min_audio_len_secs
+        self.pad_audio_mode = pad_audio_mode
+
+    def __getitem__(self, index) -> AudioNoiseItem:
+        sample = self.manifest_processor.collection[index]
+        offset = sample.offset
+
+        if offset is None:
+            offset = 0
+
+        audio = self.featurizer.process(
+            sample.audio_file,
+            offset=offset,
+            duration=sample.duration,
+            trim=self.trim,
+            orig_sr=sample.orig_sr,
+            channel_selector=self.channel_selector,
+        )
+        if audio.size(0) == 0:
+            logging.warning(f"Loaded audio has zero length: {sample}.")
+
+        min_len = int(self.min_audio_len_secs * self.featurizer.sample_rate)
+        audio = pad_audio(audio, min_len, self.pad_audio_mode)
+        audio_len = torch.tensor(audio.shape[0]).long()
+        noise, noise_len = sample_noise(self.noise_data, self.featurizer.sample_rate, audio_len.item())
+
+        item = AudioNoiseItem(
+            sample_id=str(index),
+            audio=audio,
+            audio_len=audio_len,
+            noise=noise,
+            noise_len=noise_len,
+            noisy_audio=audio + noise,
+            noisy_audio_len=audio_len,
+        )
+        return item
+
+    def _collate_fn(self, batch: List[AudioNoiseItem]) -> AudioNoiseBatch:
+        return _audio_noise_collate_fn(batch, self.batch_augmentor)
+
+
+class TarredAudioNoiseDataset(audio_to_text.TarredAudioToCharDataset):
+    @property
+    def output_types(self):
+        # disable type checking for since it doesn't support dataclass
+        return None
+
+    def __init__(
+        self,
+        noise_manifest: str | None = None,
+        batch_augmentor: Any | None = None,
+        min_audio_len_secs: float = 1.0,
+        pad_audio_mode: str = 'repeat',
+        **kwargs,
+    ):
+        """
+        Args:
+            noise_manifest: the noise manifest file
+            batch_augmentor: the batch augmentor
+            min_audio_len_secs: the minimum audio length in seconds, audios shorter than this will be padded
+            pad_audio_mode: the padding mode for audios shorter than min_audio_len_secs, either 'repeat' or 'zero'
+            **kwargs: other arguments for TarredAudioToCharDataset
+
+        """
+        super().__init__(bos_id=0, manifest_parse_func=_parse_manifest_item, **kwargs)
+        self.noise_manifest = noise_manifest
+        self.batch_augmentor = batch_augmentor
+        self.noise_data = load_noise_manifest(noise_manifest)
+        self.min_audio_len_secs = min_audio_len_secs
+        self.pad_audio_mode = pad_audio_mode
+
+    def _build_sample(self, tup):
+        """Builds the training sample by combining the data from the WebDataset with the manifest info."""
+        audio_bytes, audio_filename, offset_id = tup
+
+        # Grab manifest entry from self.manifest_preprocessor.collection
+        file_id, _ = os.path.splitext(os.path.basename(audio_filename))
+        manifest_idx = self.manifest_processor.collection.mapping[file_id][offset_id]
+        manifest_entry = self.manifest_processor.collection[manifest_idx]
+
+        offset = manifest_entry.offset
+        if offset is None:
+            offset = 0
+
+        try:
+            # Convert audio bytes to IO stream for processing (for SoundFile to read)
+            audio_filestream = io.BytesIO(audio_bytes)
+            audio = self.featurizer.process(
+                audio_filestream,
+                offset=offset,
+                duration=manifest_entry.duration,
+                trim=self.trim,
+                orig_sr=manifest_entry.orig_sr,
+            )
+            audio_filestream.close()
+        except Exception as e:
+            raise RuntimeError(f"Error reading audio sample: {manifest_entry}, with exception: {e}.")
+
+        min_len = int(self.min_audio_len_secs * self.featurizer.sample_rate)
+        audio = pad_audio(audio, min_len, self.pad_audio_mode)
+        audio_len = torch.tensor(audio.shape[0]).long()
+        noise, noise_len = sample_noise(self.noise_data, self.featurizer.sample_rate, audio_len.item())
+
+        item = AudioNoiseItem(
+            sample_id=str(manifest_idx),
+            audio=audio,
+            audio_len=audio_len,
+            noise=noise,
+            noise_len=noise_len,
+            noisy_audio=audio + noise,
+            noisy_audio_len=audio_len,
+        )
+        return item
+
+    def _pad_audio(self, audio: Tensor) -> Tensor:
+        min_len = int(self.min_audio_len_secs * self.featurizer.sample_rate)
+        if audio.size(0) < min_len:
+            if self.pad_audio_mode == 'repeat':
+                num_repeats = int(np.ceil(min_len / audio.size(0)))
+                audio = audio.repeat(num_repeats)[:min_len]
+            elif self.pad_audio_mode == 'zero':
+                audio = torch.nn.functional.pad(audio, (0, min_len - audio.size(0)))
+            else:
+                raise ValueError(
+                    f"Unsupported pad_audio_mode: {self.pad_audio_mode}, must be one of ['repeat', 'zero']"
+                )
+        return audio
+
+    def _collate_fn(self, batch: List[AudioNoiseItem]) -> AudioNoiseBatch:
+        return _audio_noise_collate_fn(batch, self.batch_augmentor)
+
+
+class LhotseAudioNoiseDataset(torch.utils.data.Dataset):
+    def __init__(self, noise_manifest: str | None = None, batch_augmentor_cfg: DictConfig = None):
+        super().__init__()
+
+        if batch_augmentor_cfg:
+            batch_augmentor = Serialization.from_config_dict(batch_augmentor_cfg)
+        else:
+            batch_augmentor = None
+
+        self.batch_augmentor = batch_augmentor
+        self.noise_data = load_noise_manifest(noise_manifest)
+        self.load_audio = AudioSamples(fault_tolerant=True)
+
+    def __getitem__(self, cuts):
+
+        audios, audio_lens, cuts = self.load_audio(cuts)
+        sampled_noises = [sample_noise(self.noise_data, cut.sampling_rate, cut.num_samples) for cut in cuts]
+
+        items = [
+            AudioNoiseItem(
+                sample_id=str(cuts[i].id),
+                audio=audios[i],
+                audio_len=audio_lens[i],
+                noise=sampled_noises[i][0],
+                noise_len=sampled_noises[i][1],
+                noisy_audio=audios[i] + sampled_noises[i][0],
+                noisy_audio_len=audio_lens[i],
+            )
+            for i in range(len(cuts))
+        ]
+        return _audio_noise_collate_fn(items, self.batch_augmentor)
+
+
+def get_audio_noise_dataset(
+    config: Dict[str, Any], augmentor: Any = None, batch_augmentor: Any = None
+) -> AudioNoiseDataset:
+    dataset = AudioNoiseDataset(
+        noise_manifest=config.get('noise_manifest', None),
+        batch_augmentor=batch_augmentor,
+        manifest_filepath=config['manifest_filepath'],
+        labels=config.get('labels', None),
+        sample_rate=config['sample_rate'],
+        int_values=config.get('int_values', False),
+        augmentor=augmentor,
+        max_duration=config.get('max_duration', None),
+        min_duration=config.get('min_duration', None),
+        trim=config.get('trim_silence', False),
+        channel_selector=config.get('channel_selector', None),
+    )
+    return dataset
+
+
+def get_concat_audio_noise_dataset(
+    config: Dict[str, Any], global_rank: int, world_size: int, augmentor: Any = None, batch_augmentor: Any = None
+) -> ConcatDataset:
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+
+    # needed to support validation Concat Datasets that arrive here as
+    # [[dataset1,dataset2]] otherwise ModelPT would interfere
+    if len(manifest_filepaths) == 1 and not isinstance(manifest_filepaths[0], str):
+        logging.info(f"removing an extra nesting level from {manifest_filepaths}")
+        manifest_filepaths = config['manifest_filepath'][0]
+
+    for manifest_filepath in manifest_filepaths:
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+
+        dataset = get_audio_noise_dataset(config=conf, augmentor=augmentor)
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_scale=config.get('concat_sampling_scale', 1),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        shuffle=config.get('concat_shuffle', True),
+        seed=config.get('concat_sampling_seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+    )
+    return dataset
+
+
+def get_tarred_audio_noise_dataset(config, shuffle_n, global_rank, world_size, augmentor, batch_augmentor: Any = None):
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    tarred_audio_filepaths = audio_to_text_dataset.convert_to_config_list(tarred_audio_filepaths)
+    manifest_filepaths = audio_to_text_dataset.convert_to_config_list(manifest_filepaths)
+
+    bucketing_weights = config.get('bucketing_weights', None)  # For upsampling buckets
+    if bucketing_weights:
+        for idx, weight in enumerate(bucketing_weights):
+            if not isinstance(weight, int) or weight <= 0:
+                raise ValueError("bucket weights must be positive integers")
+
+    if len(manifest_filepaths) != len(tarred_audio_filepaths):
+        raise ValueError(
+            f"manifest_filepaths (length={len(manifest_filepaths)}) and tarred_audio_filepaths (length={len(tarred_audio_filepaths)}) need to have the same number of buckets."
+        )
+
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        if len(tarred_audio_filepath) == 1:
+            tarred_audio_filepath = tarred_audio_filepath[0]
+        if len(manifest_filepath) == 1:
+            manifest_filepath = manifest_filepath[0]
+
+        is_sharded_manifest = True if "_OP_" in manifest_filepath and "_CL_" in manifest_filepath else False
+        logging.info(
+            f"Loading TarredAudioNoiseDataset from {tarred_audio_filepath} and {manifest_filepath}, shard={is_sharded_manifest}"
+        )
+        dataset = TarredAudioNoiseDataset(
+            noise_manifest=config.get('noise_manifest', None),
+            batch_augmentor=batch_augmentor,
+            audio_tar_filepaths=tarred_audio_filepath,
+            manifest_filepath=manifest_filepath,
+            labels=config.get('labels', None),
+            sample_rate=config['sample_rate'],
+            int_values=config.get('int_values', False),
+            augmentor=augmentor,
+            shuffle_n=shuffle_n,
+            max_duration=config.get('max_duration', None),
+            min_duration=config.get('min_duration', None),
+            trim=config.get('trim_silence', False),
+            shard_strategy=config.get('tarred_shard_strategy', 'scatter'),
+            shard_manifests=is_sharded_manifest,
+            global_rank=global_rank,
+            world_size=world_size,
+        )
+        if bucketing_weights:
+            [datasets.append(dataset) for _ in range(bucketing_weights[dataset_idx])]
+        else:
+            datasets.append(dataset)
+
+    return audio_to_text_dataset.get_chain_dataset(datasets=datasets, ds_config=config, rank=global_rank)
+
+
+def get_concat_tarred_audio_noise_dataset(
+    config, shuffle_n, global_rank, world_size, augmentor, batch_augmentor: Any = None
+):
+    tarred_audio_filepaths = config['tarred_audio_filepaths']
+    manifest_filepaths = config['manifest_filepath']
+    datasets = []
+    for dataset_idx, (tarred_audio_filepath, manifest_filepath) in enumerate(
+        zip(tarred_audio_filepaths, manifest_filepaths)
+    ):
+        conf = copy.deepcopy(config)
+        conf['manifest_filepath'] = manifest_filepath
+        conf['tarred_audio_filepaths'] = tarred_audio_filepath
+        dataset = get_tarred_audio_noise_dataset(
+            config=conf,
+            shuffle_n=shuffle_n,
+            global_rank=global_rank,
+            world_size=world_size,
+            augmentor=augmentor,
+            batch_augmentor=batch_augmentor,
+        )
+        datasets.append(dataset)
+
+    dataset = ConcatDataset(
+        datasets,
+        sampling_technique=config.get('concat_sampling_technique', 'temperature'),
+        sampling_temperature=config.get('concat_sampling_temperature', 5),
+        sampling_scale=config.get('concat_sampling_scale', 1),
+        sampling_probabilities=config.get('concat_sampling_probabilities', None),
+        shuffle=config.get('concat_shuffle', True),
+        seed=config.get('concat_sampling_seed', None),
+        global_rank=global_rank,
+        world_size=world_size,
+    )
+    return dataset
+
+
+def get_audio_noise_dataset_from_config(
+    config,
+    global_rank: int,
+    world_size: int,
+):
+    if 'augmentor' in config:
+        augmentor = process_augmentations(config['augmentor'], global_rank=global_rank, world_size=world_size)
+    else:
+        augmentor = None
+
+    if 'batch_augmentor' in config:
+        batch_augmentor = Serialization.from_config_dict(config['batch_augmentor'])
+    else:
+        batch_augmentor = None
+
+    is_concat = config.get('is_concat', False)
+    if is_concat:
+        if config.get('concat_sampling_technique', None) is None:
+            logging.warning(
+                f"Concat dataset requires `concat_sampling_technique` but it was not provided, using round-robin. Config: {config}"
+            )
+            config['concat_sampling_technique'] = 'round-robin'
+
+        if config['concat_sampling_technique'] == 'random':
+            if not 'concat_sampling_probabilities' in config:
+                logging.warning(
+                    f"Concat dataset requires `concat_sampling_probabilities` list, using uniform weights. Config: {config}"
+                )
+                with open_dict(config):
+                    config['concat_sampling_probabilities'] = [1 / len(config['manifest_filepath'])] * len(
+                        config['manifest_filepath']
+                    )
+            elif not isclose(sum(config['concat_sampling_probabilities']), 1, abs_tol=1e-6):
+                raise ValueError(
+                    f"`concat_sampling_probabilities` need to sum to 1 with 1e-6 tolerance. Config: {config}"
+                )
+
+    shuffle = config['shuffle']
+    if config.get('is_tarred', False):
+        if ('tarred_audio_filepaths' in config and config['tarred_audio_filepaths'] is None) or (
+            'manifest_filepath' in config and config['manifest_filepath'] is None
+        ):
+            logging.warning(
+                "Could not load dataset as `manifest_filepath` was None or "
+                f"`tarred_audio_filepaths` is None. Provided config : {config}"
+            )
+            return None
+
+        shuffle_n = config.get('shuffle_n', 4 * config['batch_size']) if shuffle else 0
+        if is_concat:
+            dataset = get_concat_tarred_audio_noise_dataset(
+                config=config,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+                batch_augmentor=batch_augmentor,
+            )
+        else:
+            dataset = get_tarred_audio_noise_dataset(
+                config=config,
+                shuffle_n=shuffle_n,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+                batch_augmentor=batch_augmentor,
+            )
+    else:
+        if 'manifest_filepath' in config and config['manifest_filepath'] is None:
+            logging.warning(f"Could not load dataset as `manifest_filepath` was None. Provided config : {config}")
+            return None
+        if is_concat:
+            dataset = get_concat_audio_noise_dataset(
+                config=config,
+                global_rank=global_rank,
+                world_size=world_size,
+                augmentor=augmentor,
+                batch_augmentor=batch_augmentor,
+            )
+        else:
+            dataset = get_audio_noise_dataset(config=config, augmentor=augmentor, batch_augmentor=batch_augmentor)
+    return dataset

nemo/collections/asr/data/text_to_text.py

@@ -0,0 +1,482 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+#
+# 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.
+
+from __future__ import annotations
+
+import concurrent.futures
+import copy
+import gc
+import json
+import math
+import random
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, NamedTuple, Optional, Set, Union
+
+import numpy as np
+import torch
+import torch.utils.data
+from torch.nn.utils.rnn import pad_sequence
+from tqdm.auto import tqdm
+
+from nemo.collections.asr.data.audio_to_text import _speech_collate_fn
+from nemo.collections.common.tokenizers import TokenizerSpec
+from nemo.core.classes import Dataset, IterableDataset
+from nemo.utils import logging
+
+try:
+    from nemo_text_processing.text_normalization.normalize import Normalizer
+except Exception as e:
+    pass  # Normalizer imported only for annotation purposes, error can be ignored
+
+AnyPath = Union[Path, str]
+
+
+class TextToTextItem(NamedTuple):
+    tts_text: torch.Tensor  # normalized and tokenized text for TTS
+    transcript: torch.Tensor  # tokenized text for ASR
+    speaker: int  # speaker id for multi-speaker TTS
+
+
+class TextToTextBatch(NamedTuple):
+    tts_texts: torch.Tensor  # tokenized texts for tts
+    tts_text_lengths: torch.Tensor
+    transcripts: torch.Tensor  # tokenized texts for ASR
+    transcript_lengths: torch.Tensor
+    speakers: torch.Tensor  # speaker ids for multi-speaker TTS
+
+    @staticmethod
+    def collate_fn(batch: List[TextToTextItem], asr_pad_id: int, tts_text_pad_id: int) -> TextToTextBatch:
+        return TextToTextBatch(
+            tts_texts=pad_sequence([item.tts_text for item in batch], batch_first=True, padding_value=tts_text_pad_id),
+            tts_text_lengths=torch.tensor([item.tts_text.shape[0] for item in batch]).long(),
+            transcripts=pad_sequence([item.transcript for item in batch], batch_first=True, padding_value=asr_pad_id),
+            transcript_lengths=torch.tensor([item.transcript.shape[0] for item in batch]).long(),
+            speakers=torch.tensor([item.speaker for item in batch]).long(),
+        )
+
+
+class TextOrAudioToTextBatch(NamedTuple):
+    audio_signals: torch.Tensor
+    audio_signal_lengths: torch.Tensor
+    tts_texts: torch.Tensor
+    tts_text_lengths: torch.Tensor
+    speakers: torch.Tensor
+    transcripts: torch.Tensor
+    transcript_lengths: torch.Tensor
+
+    @staticmethod
+    def collate_fn(
+        batch: List[Union[TextToTextItem, tuple]], tts_text_pad_id: int, asr_pad_id: int
+    ) -> Union[TextToTextBatch, TextOrAudioToTextBatch, tuple]:
+        """
+        Collate function for dataloader
+        Can accept mixed batch of text-to-text items and audio-text items (typical for ASR)
+        """
+        text_items: List[TextToTextItem] = [item for item in batch if isinstance(item, TextToTextItem)]
+        if not text_items:
+            # pure audio-text batch
+            return _speech_collate_fn(batch=batch, pad_id=asr_pad_id)
+
+        asr_items = [item for item in batch if not isinstance(item, TextToTextItem)]
+
+        if not asr_items:
+            # pure text-to-text batch
+            return TextToTextBatch.collate_fn(batch=text_items, asr_pad_id=asr_pad_id, tts_text_pad_id=tts_text_pad_id)
+
+        # mixed batch
+
+        # each asr item is a tuple:
+        # audio_signal (0), audio_length (1), transcript (2), transcript_length (3), sample_id (4, optional)
+        audio_signals = pad_sequence([item[0] for item in asr_items], batch_first=True, padding_value=0.0)
+        audio_signal_lengths = torch.tensor([item[1] for item in asr_items]).long()
+
+        tts_texts = pad_sequence(
+            [item.tts_text for item in text_items], batch_first=True, padding_value=tts_text_pad_id
+        )
+        tts_text_lengths = torch.tensor([item.tts_text.shape[0] for item in text_items]).long()
+        speakers = torch.tensor([item.speaker for item in text_items]).long()
+
+        transcripts = pad_sequence(
+            [item.transcript for item in text_items] + [item[2] for item in asr_items],
+            batch_first=True,
+            padding_value=asr_pad_id,
+        )
+        transcript_lengths = torch.tensor(
+            [item.transcript.shape[0] for item in text_items] + [item[3] for item in asr_items]
+        ).long()
+
+        return TextOrAudioToTextBatch(
+            audio_signals=audio_signals,
+            audio_signal_lengths=audio_signal_lengths,
+            tts_texts=tts_texts,
+            tts_text_lengths=tts_text_lengths,
+            speakers=speakers,
+            transcripts=transcripts,
+            transcript_lengths=transcript_lengths,
+        )
+
+
+def _asr_text_to_tokens(text: str) -> np.ndarray:
+    """
+    Helper function for asr tokenization with multiprocessing pool only.
+    Must be defined on the top level.
+    Expects asr_tokenizer_global, asr_bos_id_global, asr_eos_id_global to exist in the current pool process
+    """
+    ids = asr_tokenizer_global.text_to_ids(text)
+    if asr_bos_id_global is not None:
+        ids = [asr_bos_id_global] + ids
+    if asr_eos_id_global is not None:
+        ids.append(asr_eos_id_global)
+    return np.asarray(ids)
+
+
+def _tts_text_to_tokens(text: str) -> np.ndarray:
+    """
+    Helper function for asr tokenization with multiprocessing pool only.
+    Must be defined on the top level.
+    Expects tts_tokenizer_global to exist in the current pool process
+    """
+    return np.asarray(tts_tokenizer_global(text))
+
+
+def _iterate_manifest(filepath: AnyPath) -> Iterable[Dict[str, Any]]:
+    """
+    Helper function to iterate manifest
+    """
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            record = json.loads(line)
+            yield record
+
+
+class TextToTextDatasetBase:
+    """
+    Base class for loading text-to-text manifests
+    Map-style and Iterable datasets should inherit this class
+    """
+
+    asr_pad_id: int
+    tts_text_pad_id: int
+    asr_bos_id: Optional[int] = None
+    asr_eos_id: Optional[int] = None
+    data: List[Dict[str, Any]]
+
+    def __init__(
+        self,
+        manifest_filepath: Union[AnyPath, List[AnyPath]],
+        speakers_filepath: Union[AnyPath, List[AnyPath]],
+        asr_tokenizer: TokenizerSpec,
+        asr_use_start_end_token: bool,
+        tts_parser: Callable,
+        tts_text_pad_id: int,
+        tts_text_normalizer: "Normalizer",
+        tts_text_normalizer_call_kwargs: Dict,
+        min_words: int = 1,
+        max_words: int = 1_000_000,
+        tokenizer_workers: int = 1,
+        num_parts: int = 1,
+        current_part_index: int = 0,
+    ):
+        super().__init__()
+        # ASR tokenizer setup
+        if asr_use_start_end_token and hasattr(asr_tokenizer, 'bos_token'):
+            self.asr_bos_id = asr_tokenizer.bos_id
+
+        if asr_use_start_end_token and hasattr(asr_tokenizer, 'eos_token'):
+            self.asr_eos_id = asr_tokenizer.eos_id
+
+        if hasattr(asr_tokenizer, 'pad_token'):
+            self.asr_pad_id = asr_tokenizer.pad_id
+        else:
+            self.asr_pad_id = 0
+
+        self.asr_tokenizer = asr_tokenizer
+
+        # TTS tokenizer setup
+        self.tts_parser = tts_parser
+        self.tts_normalizer = tts_text_normalizer
+        self.tts_normalizer_kwargs = tts_text_normalizer_call_kwargs
+        self.tts_text_pad_id = tts_text_pad_id
+
+        # Load speakers
+        if isinstance(speakers_filepath, str):
+            speakers_filepath = speakers_filepath.split(",")
+        elif isinstance(speakers_filepath, Path):
+            speakers_filepath = [speakers_filepath]
+        speakers: Set[int] = set()
+        for filepath in speakers_filepath:
+            with open(Path(filepath).expanduser(), "r") as f:
+                speakers.update(map(int, f.read().split()))
+        self.speakers = np.asarray(sorted(speakers))
+        logging.info(f"Loaded {len(self.speakers)} speakers")
+
+        # Load manifest
+        if isinstance(manifest_filepath, str):
+            manifest_filepath = manifest_filepath.split(",")
+        elif isinstance(manifest_filepath, Path):
+            manifest_filepath = [manifest_filepath]
+        self.manifest_paths = [Path(filepath) for filepath in manifest_filepath]
+
+        num_skipped_words = 0
+        num_skipped_utterances = 0
+        asr_texts = []
+        tts_texts = []
+        need_normalization = False
+
+        for manifest_path in self.manifest_paths:
+            for tmp_item in tqdm(_iterate_manifest(manifest_path)):
+                text = tmp_item["text"]
+                num_words = len(text.split())
+                # skip if number of works not in desired range
+                # TODO: maybe it would be valuable to sample sub-utterances from long utterances
+                if not (min_words <= num_words <= max_words):
+                    num_skipped_words += num_words
+                    num_skipped_utterances += 1
+                    continue
+                asr_texts.append(tmp_item["text"])
+                if "tts_text_normalized" in tmp_item:
+                    tts_texts.append(tmp_item["tts_text_normalized"])
+                else:
+                    tts_texts.append(tmp_item["tts_text"])
+                    need_normalization = True
+
+        if need_normalization:
+            logging.warning("TTS normalization is extremely slow! It is recommended to normalize TTS text")
+
+        if num_skipped_utterances:
+            logging.warning(f"Skipped {num_skipped_utterances} utterances " f"with {num_skipped_words}")
+
+        num_utterances = len(asr_texts)
+        # preprocessing is very costly, if we need only part - remove unnecessary utterances
+        if num_parts > 1:
+            # NB: floor division, full dataset can contain fewer utterances than original, like in tarred dataset
+            num_utterances_part = num_utterances // num_parts
+            start = num_utterances_part * current_part_index
+            end = start + num_utterances_part
+            logging.info(
+                f"Taking part of the dataset: {current_part_index} index, total {num_parts} from {start} to {end}"
+            )
+            asr_texts = asr_texts[start:end]
+            tts_texts = tts_texts[start:end]
+            num_utterances = num_utterances_part
+
+        self.data = [dict() for _ in range(num_utterances)]
+
+        if len(asr_texts) == 0:
+            # no data was loaded
+            logging.warning("Text-to-text dataset is empty")
+            return
+
+        if tokenizer_workers == 1:
+            logging.warning(
+                "Preprocessing large text with tokenizer_workers=1 may be slow with TTS tokenizer. "
+                "Prefer tokenizer_workers=(num_cpu_cores/num_gpus_per_node)"
+            )
+            for i, tokenized_text in enumerate(
+                tqdm((self._asr_text_to_tokens(text) for text in asr_texts), total=len(asr_texts))
+            ):
+                self.data[i]["asr_text_tokens"] = tokenized_text
+        else:
+            # Multiprocessing hack: use global variables for every process (not really global in program context)
+            def _init_asr_tokenize_process(tokenizer, bos_id, eos_id):
+                global asr_tokenizer_global, asr_bos_id_global, asr_eos_id_global  # process-global
+                # deepcopy to avoid serialization of parent models
+                asr_tokenizer_global = copy.deepcopy(tokenizer)
+                asr_bos_id_global = copy.deepcopy(bos_id)
+                asr_eos_id_global = copy.deepcopy(eos_id)
+
+            with concurrent.futures.ProcessPoolExecutor(
+                initializer=_init_asr_tokenize_process,
+                initargs=(asr_tokenizer, self.asr_bos_id, self.asr_eos_id),
+                max_workers=tokenizer_workers,
+            ) as pool:
+                # chunk size for pool map is empirically chosen as a trade-off between speed and responsiveness
+                for i, tokenized_text in enumerate(
+                    tqdm(pool.map(_asr_text_to_tokens, asr_texts, chunksize=1000), total=len(asr_texts))
+                ):
+                    self.data[i]["asr_text_tokens"] = tokenized_text
+        # force free memory
+        del asr_texts
+        gc.collect()
+
+        if tokenizer_workers == 1:
+            logging.warning(
+                "Preprocessing large text with tokenizer_workers=1 may be slow with TTS tokenizer. "
+                "Prefer tokenizer_workers=(num_cpu_cores/num_gpus_per_node)"
+            )
+            for i, tokenized_text in enumerate(
+                tqdm(
+                    (self._tts_text_to_tokens(text, normalize=need_normalization) for text in tts_texts),
+                    total=len(tts_texts),
+                )
+            ):
+                self.data[i]["tts_text_tokens"] = tokenized_text
+        else:
+            if need_normalization:
+                # TODO: implement, if we really need normalization inplace
+                raise NotImplementedError(
+                    "Normalization with tokenizer_workers > 1 is not implemented. "
+                    "It is not recommended to use normalization on the fly at all, since it's extremely slow"
+                )
+
+            def _init_tts_tokenize_process(tokenizer):
+                global tts_tokenizer_global  # process-global
+                tts_tokenizer_global = copy.deepcopy(tokenizer)
+
+            with concurrent.futures.ProcessPoolExecutor(
+                initializer=_init_tts_tokenize_process, initargs=(tts_parser,), max_workers=tokenizer_workers,
+            ) as pool:
+                # chunk size for pool map is empirically chosen as a trade-off between speed and responsiveness
+                for i, tokenized_text in enumerate(
+                    tqdm(pool.map(_tts_text_to_tokens, tts_texts, chunksize=1000), total=len(tts_texts))
+                ):
+                    self.data[i]["tts_text_tokens"] = tokenized_text
+        # force free memory
+        del tts_texts
+        gc.collect()
+
+    def _asr_text_to_tokens(self, text: str) -> np.ndarray:
+        ids = self.asr_tokenizer.text_to_ids(text)
+        if self.asr_bos_id is not None:
+            ids = [self.asr_bos_id] + ids
+        if self.asr_eos_id is not None:
+            ids.append(self.asr_eos_id)
+        return np.asarray(ids)
+
+    def _tts_text_to_tokens(self, text: str, normalize=True) -> np.ndarray:
+        if normalize:
+            text = self.tts_normalizer.normalize(text, **self.tts_normalizer_kwargs)
+        tokens = self.tts_parser(text)
+        return np.asarray(tokens)
+
+    def __getitem__(self, index):
+        item = self.data[index]
+        return TextToTextItem(
+            transcript=torch.from_numpy(item["asr_text_tokens"]).long(),
+            tts_text=torch.from_numpy(item["tts_text_tokens"]).long(),
+            speaker=random.choice(self.speakers),
+        )
+
+    def __len__(self):
+        return len(self.data)
+
+
+class TextToTextDataset(TextToTextDatasetBase, Dataset):
+    """Text-to-Text Map-style Dataset for hybrid ASR-TTS models"""
+
+    def __init__(
+        self,
+        manifest_filepath: Union[AnyPath, List[AnyPath]],
+        speakers_filepath: Union[AnyPath, List[AnyPath]],
+        asr_tokenizer: TokenizerSpec,
+        asr_use_start_end_token: bool,
+        tts_parser: Callable,
+        tts_text_pad_id: int,
+        tts_text_normalizer: "Normalizer",
+        tts_text_normalizer_call_kwargs: Dict,
+        min_words: int = 1,
+        max_words: int = 1_000_000,
+        tokenizer_workers: int = 1,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            speakers_filepath=speakers_filepath,
+            asr_tokenizer=asr_tokenizer,
+            asr_use_start_end_token=asr_use_start_end_token,
+            tts_parser=tts_parser,
+            tts_text_pad_id=tts_text_pad_id,
+            tts_text_normalizer=tts_text_normalizer,
+            tts_text_normalizer_call_kwargs=tts_text_normalizer_call_kwargs,
+            min_words=min_words,
+            max_words=max_words,
+            tokenizer_workers=tokenizer_workers,
+            num_parts=1,
+        )
+
+    def collate_fn(
+        self, batch: List[Union[TextToTextItem, tuple]]
+    ) -> Union[TextToTextBatch, TextOrAudioToTextBatch, tuple]:
+        """
+        Collate function for dataloader
+        Can accept mixed batch of text-to-text items and audio-text items (typical for ASR)
+        """
+        return TextOrAudioToTextBatch.collate_fn(
+            batch=batch, asr_pad_id=self.asr_pad_id, tts_text_pad_id=self.tts_text_pad_id
+        )
+
+
+class TextToTextIterableDataset(TextToTextDatasetBase, IterableDataset):
+    """
+    Text-to-Text Iterable Dataset for hybrid ASR-TTS models
+    Only part necessary for current process should be loaded and stored
+    """
+
+    def __init__(
+        self,
+        manifest_filepath: Union[AnyPath, List[AnyPath]],
+        speakers_filepath: Union[AnyPath, List[AnyPath]],
+        asr_tokenizer: TokenizerSpec,
+        asr_use_start_end_token: bool,
+        tts_parser: Callable,
+        tts_text_pad_id: int,
+        tts_text_normalizer: "Normalizer",
+        tts_text_normalizer_call_kwargs: Dict,
+        min_words: int = 1,
+        max_words: int = 1_000_000,
+        tokenizer_workers: int = 1,
+        num_parts: int = 1,
+        current_part_index: int = 0,
+    ):
+        super().__init__(
+            manifest_filepath=manifest_filepath,
+            speakers_filepath=speakers_filepath,
+            asr_tokenizer=asr_tokenizer,
+            asr_use_start_end_token=asr_use_start_end_token,
+            tts_parser=tts_parser,
+            tts_text_pad_id=tts_text_pad_id,
+            tts_text_normalizer=tts_text_normalizer,
+            tts_text_normalizer_call_kwargs=tts_text_normalizer_call_kwargs,
+            min_words=min_words,
+            max_words=max_words,
+            tokenizer_workers=tokenizer_workers,
+            num_parts=num_parts,
+            current_part_index=current_part_index,
+        )
+
+    def __iter__(self):
+        # Implementation based on docs: https://pytorch.org/docs/stable/data.html#torch.utils.data.IterableDataset
+        worker_info = torch.utils.data.get_worker_info()
+        if worker_info is None:  # single-process data loading, return the full iterator
+            start = 0
+            end = len(self)
+        else:  # in a worker process
+            # split workload
+            per_worker = int(math.ceil(len(self) / float(worker_info.num_workers)))
+            worker_id = worker_info.id
+            start = worker_id * per_worker
+            end = min(start + per_worker, len(self))
+        indices = np.arange(start, end)
+        np.random.shuffle(indices)
+        return map(self.__getitem__, indices)
+
+    def collate_fn(
+        self, batch: List[Union[TextToTextItem, tuple]]
+    ) -> Union[TextToTextBatch, TextOrAudioToTextBatch, tuple]:
+        """
+        Collate function for dataloader
+        Can accept mixed batch of text-to-text items and audio-text items (typical for ASR)
+        """
+        return TextOrAudioToTextBatch.collate_fn(
+            batch=batch, asr_pad_id=self.asr_pad_id, tts_text_pad_id=self.tts_text_pad_id
+        )

nemo/collections/asr/losses/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr.losses.angularloss import AngularSoftmaxLoss
+from nemo.collections.asr.losses.bce_loss import BCELoss
+from nemo.collections.asr.losses.ctc import CTCLoss
+from nemo.collections.asr.losses.lattice_losses import LatticeLoss
+from nemo.collections.asr.losses.ssl_losses.contrastive import ContrastiveLoss
+from nemo.collections.asr.losses.ssl_losses.ctc import CTCLossForSSL
+from nemo.collections.asr.losses.ssl_losses.mlm import MLMLoss, MultiMLMLoss
+from nemo.collections.asr.losses.ssl_losses.rnnt import RNNTLossForSSL

nemo/collections/asr/losses/angularloss.py

@@ -0,0 +1,68 @@
+# ! /usr/bin/python
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 torch
+
+from nemo.core.classes import Loss, Typing, typecheck
+from nemo.core.neural_types import LabelsType, LogitsType, LossType, NeuralType
+
+__all__ = ['AngularSoftmaxLoss']
+
+
+class AngularSoftmaxLoss(Loss, Typing):
+    """
+    Computes ArcFace Angular softmax angle loss
+    reference: https://openaccess.thecvf.com/content_CVPR_2019/papers/Deng_ArcFace_Additive_Angular_Margin_Loss_for_Deep_Face_Recognition_CVPR_2019_paper.pdf
+    args:
+    scale: scale value for cosine angle
+    margin: margin value added to cosine angle 
+    """
+
+    @property
+    def input_types(self):
+        """Input types definitions for AnguarLoss.
+        """
+        return {
+            "logits": NeuralType(('B', 'D'), LogitsType()),
+            "labels": NeuralType(('B',), LabelsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for AngularLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, scale=20.0, margin=1.35):
+        super().__init__()
+
+        self.eps = 1e-7
+        self.scale = scale
+        self.margin = margin
+
+    @typecheck()
+    def forward(self, logits, labels):
+        numerator = self.scale * torch.cos(
+            torch.acos(torch.clamp(torch.diagonal(logits.transpose(0, 1)[labels]), -1.0 + self.eps, 1 - self.eps))
+            + self.margin
+        )
+        excl = torch.cat(
+            [torch.cat((logits[i, :y], logits[i, y + 1 :])).unsqueeze(0) for i, y in enumerate(labels)], dim=0
+        )
+        denominator = torch.exp(numerator) + torch.sum(torch.exp(self.scale * excl), dim=1)
+        L = numerator - torch.log(denominator)
+        return -torch.mean(L)

nemo/collections/asr/losses/bce_loss.py

@@ -0,0 +1,135 @@
+# ! /usr/bin/python
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 torch
+
+from nemo.core.classes import Loss, Typing, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LossType, NeuralType, ProbsType
+
+__all__ = ['BCELoss']
+
+
+class BCELoss(Loss, Typing):
+    """
+    Computes Binary Cross Entropy (BCE) loss. The BCELoss class expects output from Sigmoid function.
+    """
+
+    @property
+    def input_types(self):
+        """Input types definitions for AnguarLoss."""
+        return {
+            "probs": NeuralType(('B', 'T', 'C'), ProbsType()),
+            'labels': NeuralType(('B', 'T', 'C'), LabelsType()),
+            "target_lens": NeuralType(('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """
+        Output types definitions for binary cross entropy loss. Weights for labels can be set using weight variables.
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(
+        self,
+        reduction: str = 'mean',
+        alpha: float = 1.0,
+        weight: torch.Tensor = torch.tensor([0.1, 0.9]),
+        sorted_preds: bool = False,
+        sorted_loss: bool = False,
+        class_normalization: bool = False,
+    ):
+        """
+        A custom loss function that supports class normalization,
+        weighted binary cross-entropy, and optional sorting.
+
+        Args:
+            reduction (str): Specifies the reduction to apply to the output,
+                options are 'mean', 'sum', or 'none'. Default is 'mean'.
+            alpha (float): Scaling factor for loss (unused in this implementation). Default is 1.0.
+            weight (torch.Tensor): Class weights for the binary cross-entropy loss. Default is [0.1, 0.9].
+            sorted_preds (bool): If True, assumes predictions are sorted. Default is False.
+            sorted_loss (bool): If True, sorts the loss before reduction. Default is False.
+            class_normalization (bool): If True, uses 'none' reduction for per-class loss. Default is False.
+        """
+        super().__init__()
+        self.class_normalization = class_normalization
+        if class_normalization:
+            self.reduction = 'none'
+        else:
+            self.reduction = 'mean'
+        self.loss_weight = weight
+        self.loss_f = torch.nn.BCELoss(reduction=self.reduction)
+        self.sorted_preds = sorted_preds
+        self.sorted_loss = sorted_loss
+        self.eps = 1e-6
+
+    @typecheck()
+    def forward(self, probs, labels, target_lens):
+        """
+        Calculate binary cross entropy loss based on probs, labels and target_lens variables.
+
+        Args:
+            probs (torch.tensor)
+                Predicted probability value which ranges from 0 to 1. Sigmoid output is expected.
+            labels (torch.tensor)
+                Groundtruth label for the predicted samples.
+            target_lens (torch.tensor):
+                The actual length of the sequence without zero-padding.
+
+        Returns:
+            loss (NeuralType)
+                Binary cross entropy loss value.
+        """
+        probs_list = [probs[k, : target_lens[k], :] for k in range(probs.shape[0])]
+        targets_list = [labels[k, : target_lens[k], :] for k in range(labels.shape[0])]
+        probs = torch.cat(probs_list, dim=0)
+        labels = torch.cat(targets_list, dim=0)
+        norm_weight = torch.zeros_like(labels).detach().clone()
+        loss = torch.tensor(0.0).to(labels.device)
+
+        if self.class_normalization in ['class', 'class_binary', 'binary']:
+            if self.class_normalization in ['class', 'class_binary']:
+                # Normalize loss by number of classes
+                norm_weight = 1 / (labels.sum(dim=0) + self.eps)
+                norm_weight_norm = norm_weight / norm_weight.sum()
+                norm_weight_norm = torch.clamp(norm_weight_norm, min=0.05, max=1.0)
+                norm_weight_norm = norm_weight_norm / norm_weight_norm.max()
+                norm_weight = norm_weight_norm[None, :].expand_as(labels).detach().clone()
+            else:
+                norm_weight = torch.ones_like(labels).detach().clone()
+
+            if self.class_normalization in ['binary', 'class_binary']:
+                binary_weight = torch.ones_like(labels).detach().clone()
+                one_weight = (labels.sum() / (labels.shape[0] * labels.shape[1])).to(labels.device)
+                binary_weight[labels == 0] = one_weight
+                binary_weight[labels == 1] = 1 - one_weight
+            else:
+                binary_weight = torch.ones_like(labels).detach().clone()
+
+        elif self.class_normalization == 'none' or not self.class_normalization:
+            binary_weight = torch.ones_like(labels).detach().clone()
+            norm_weight = torch.ones_like(labels).detach().clone()
+
+        if self.reduction == 'sum':
+            loss = self.loss_f(probs, labels)
+        elif self.reduction == 'mean':
+            loss = self.loss_f(probs, labels).mean()
+        elif self.reduction == 'none':
+            if self.class_normalization in ['class', 'class_binary', 'binary']:
+                loss = (binary_weight * norm_weight * self.loss_f(probs, labels)).sum()
+            else:
+                loss = self.loss_f(probs, labels)
+        return loss

nemo/collections/asr/losses/ctc.py

@@ -0,0 +1,82 @@
+# ! /usr/bin/python
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 torch
+from torch import nn
+
+from nemo.core.classes import Serialization, Typing, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType
+
+__all__ = ['CTCLoss']
+
+
+class CTCLoss(nn.CTCLoss, Serialization, Typing):
+    @property
+    def input_types(self):
+        """Input types definitions for CTCLoss.
+        """
+        return {
+            "log_probs": NeuralType(('B', 'T', 'D'), LogprobsType()),
+            "targets": NeuralType(('B', 'T'), LabelsType()),
+            "input_lengths": NeuralType(tuple('B'), LengthsType()),
+            "target_lengths": NeuralType(tuple('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for CTCLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, num_classes, zero_infinity=False, reduction='mean_batch'):
+        self._blank = num_classes
+        # Don't forget to properly call base constructor
+        if reduction not in ['none', 'mean', 'sum', 'mean_batch', 'mean_volume']:
+            raise ValueError('`reduction` must be one of [mean, sum, mean_batch, mean_volume]')
+
+        self.config_reduction = reduction
+        if reduction == 'mean_batch' or reduction == 'mean_volume':
+            ctc_reduction = 'none'
+            self._apply_reduction = True
+        elif reduction in ['sum', 'mean', 'none']:
+            ctc_reduction = reduction
+            self._apply_reduction = False
+        super().__init__(blank=self._blank, reduction=ctc_reduction, zero_infinity=zero_infinity)
+
+    def reduce(self, losses, target_lengths):
+        if self.config_reduction == 'mean_batch':
+            losses = losses.mean()  # global batch size average
+        elif self.config_reduction == 'mean_volume':
+            losses = losses.sum() / target_lengths.sum()  # same as above but longer samples weigh more
+
+        return losses
+
+    @typecheck()
+    def forward(self, log_probs, targets, input_lengths, target_lengths):
+        # override forward implementation
+        # custom logic, if necessary
+        input_lengths = input_lengths.long()
+        target_lengths = target_lengths.long()
+        targets = targets.long()
+        # here we transpose because we expect [B, T, D] while PyTorch assumes [T, B, D]
+        log_probs = log_probs.transpose(1, 0)
+        loss = super().forward(
+            log_probs=log_probs, targets=targets, input_lengths=input_lengths, target_lengths=target_lengths
+        )
+        if self._apply_reduction:
+            loss = self.reduce(loss, target_lengths)
+        return loss

nemo/collections/asr/losses/lattice_losses.py

@@ -0,0 +1,184 @@
+# ! /usr/bin/python
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Optional
+
+import torch
+from omegaconf import DictConfig
+
+from nemo.core.classes import Loss, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType
+
+
+class LatticeLoss(Loss):
+    """Family of loss functions based on various lattice scores.
+
+    Note:
+        Requires k2 v1.14 or later to be installed to use this loss function.
+
+    Losses can be selected via the config, and optionally be passed keyword arguments as follows.
+
+    Examples:
+        .. code-block:: yaml
+
+            model:  # Model config
+                ...
+                graph_module_cfg:  # Config for graph modules, e.g. LatticeLoss
+                    criterion_type: "map"
+                    loss_type: "mmi"
+                    split_batch_size: 0
+                    backend_cfg:
+                        topo_type: "default"       # other options: "compact", "shared_blank", "minimal"
+                        topo_with_self_loops: true
+                        token_lm: <token_lm_path>  # must be provided for criterion_type: "map"
+
+    Args:
+        num_classes: Number of target classes for the decoder network to predict.
+            (Excluding the blank token).
+
+        reduction: Type of reduction to perform on loss. Possible values are `mean_batch`, `mean`, `sum`, or None.
+            None will return a torch vector comprising the individual loss values of the batch.
+
+        backend: Which backend to use for loss calculation. Currently only `k2` is supported.
+
+        criterion_type: Type of criterion to use. Choices: `ml` and `map`, 
+            with `ml` standing for Maximum Likelihood and `map` for Maximum A Posteriori Probability.
+
+        loss_type: Type of the loss function to use. Choices: `ctc` and `rnnt` for `ml`, and `mmi` for `map`.
+
+        split_batch_size: Local batch size. Used for memory consumption reduction at the cost of speed performance.
+            Effective if complies 0 < split_batch_size < batch_size.
+
+        graph_module_cfg: Optional Dict of (str, value) pairs that are passed to the backend loss function.
+    """
+
+    @property
+    def input_types(self):
+        """Input types definitions for LatticeLoss.
+        """
+        return {
+            "log_probs": NeuralType(("B", "T", "D") if self._3d_input else ("B", "T", "T", "D"), LogprobsType()),
+            "targets": NeuralType(("B", "T"), LabelsType()),
+            "input_lengths": NeuralType(tuple("B"), LengthsType()),
+            "target_lengths": NeuralType(tuple("B"), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for LatticeLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(
+        self,
+        num_classes: int,
+        reduction: str = "mean_batch",
+        backend: str = "k2",
+        criterion_type: str = "ml",
+        loss_type: str = "ctc",
+        split_batch_size: int = 0,
+        graph_module_cfg: Optional[DictConfig] = None,
+    ):
+        super().__init__()
+        self._blank = num_classes
+        self.split_batch_size = split_batch_size
+        inner_reduction = None
+        if reduction == "mean_batch":
+            inner_reduction = "none"
+            self._apply_batch_mean = True
+        elif reduction in ["sum", "mean", "none"]:
+            inner_reduction = reduction
+            self._apply_batch_mean = False
+
+        # we assume that self._blank + 1 == num_classes
+        if backend == "k2":
+            if criterion_type == "ml":
+                if loss_type == "ctc":
+                    from nemo.collections.asr.parts.k2.ml_loss import CtcLoss as K2Loss
+                elif loss_type == "rnnt":
+                    from nemo.collections.asr.parts.k2.ml_loss import RnntLoss as K2Loss
+                else:
+                    raise ValueError(f"Unsupported `loss_type`: {loss_type}.")
+            elif criterion_type == "map":
+                if loss_type == "ctc":
+                    from nemo.collections.asr.parts.k2.map_loss import CtcMmiLoss as K2Loss
+                else:
+                    raise ValueError(f"Unsupported `loss_type`: {loss_type}.")
+            else:
+                raise ValueError(f"Unsupported `criterion_type`: {criterion_type}.")
+
+            self._loss = K2Loss(
+                num_classes=self._blank + 1, blank=self._blank, reduction=inner_reduction, cfg=graph_module_cfg,
+            )
+        elif backend == "gtn":
+            raise NotImplementedError(f"Backend {backend} is not supported.")
+        else:
+            raise ValueError(f"Invalid value of `backend`: {backend}.")
+
+        self.criterion_type = criterion_type
+        self.loss_type = loss_type
+        self._3d_input = self.loss_type != "rnnt"
+
+        if self.split_batch_size > 0:
+            # don't need to guard grad_utils
+            from nemo.collections.asr.parts.k2.grad_utils import PartialGrad
+
+            self._partial_loss = PartialGrad(self._loss)
+
+    def update_graph(self, graph):
+        """Updates graph of the backend loss function.
+        """
+        if self.criterion_type != "ml":
+            self._loss.update_graph(graph)
+
+    @typecheck()
+    def forward(self, log_probs, targets, input_lengths, target_lengths):
+        # override forward implementation
+        # custom logic, if necessary
+
+        assert not (torch.isnan(log_probs).any() or torch.isinf(log_probs).any())
+
+        log_probs = log_probs.float()
+        input_lengths = input_lengths.long()
+        target_lengths = target_lengths.long()
+        targets = targets.long()
+        batch_size = log_probs.shape[0]
+        if self.split_batch_size > 0 and self.split_batch_size <= batch_size:
+            loss_list = []
+            for batch_idx in range(0, batch_size, self.split_batch_size):
+                begin = batch_idx
+                end = min(begin + self.split_batch_size, batch_size)
+                input_lengths_part = input_lengths[begin:end]
+                log_probs_part = log_probs[begin:end, : input_lengths_part.max()]
+                target_lengths_part = target_lengths[begin:end]
+                targets_part = targets[begin:end, : target_lengths_part.max()]
+                loss_part, _ = (
+                    self._partial_loss(log_probs_part, targets_part, input_lengths_part, target_lengths_part)
+                    if log_probs_part.requires_grad
+                    else self._loss(log_probs_part, targets_part, input_lengths_part, target_lengths_part)
+                )
+                del log_probs_part, targets_part, input_lengths_part, target_lengths_part
+                loss_list.append(loss_part)
+            loss = torch.cat(loss_list, 0)
+        else:
+            loss, _ = self._loss(
+                log_probs=log_probs, targets=targets, input_lengths=input_lengths, target_lengths=target_lengths,
+            )
+        if self._apply_batch_mean:
+            # torch.mean gives nan if loss is empty
+            loss = torch.mean(loss) if loss.nelement() > 0 else torch.sum(loss)
+        return loss

nemo/collections/asr/losses/rnnt.py

@@ -0,0 +1,508 @@
+# ! /usr/bin/python
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+# Copyright 2018-2019, Mingkun Huang
+#
+# 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 inspect
+import operator
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Set
+
+import torch
+from omegaconf import DictConfig, OmegaConf
+
+from nemo.collections.asr.losses.rnnt_pytorch import MultiblankRNNTLossPytorch, RNNTLossPytorch, TDTLossPytorch
+from nemo.core.classes import Loss, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType
+from nemo.core.utils import numba_utils
+from nemo.core.utils.k2_utils import K2_INSTALLATION_MESSAGE
+from nemo.core.utils.numba_utils import NUMBA_INSTALLATION_MESSAGE
+from nemo.utils import logging, logging_mode, model_utils
+
+try:
+    import warprnnt_pytorch as warprnnt
+
+    WARP_RNNT_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    WARP_RNNT_AVAILABLE = False
+
+try:
+    from nemo.collections.asr.parts.numba.rnnt_loss import MultiblankRNNTLossNumba, RNNTLossNumba, TDTLossNumba
+
+    NUMBA_RNNT_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    NUMBA_RNNT_AVAILABLE = False
+
+try:
+    from nemo.collections.asr.parts.k2.graph_transducer import GraphRnntLoss
+    from nemo.collections.asr.parts.k2.w_transducer import GraphWTransducerLoss
+
+    K2_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    K2_AVAILABLE = False
+
+WARP_RNNT_INSTALLATION_MESSAGE = (
+    "Could not import `warprnnt_pytorch`.\n"
+    "Please visit https://github.com/HawkAaron/warp-transducer "
+    "and follow the steps in the readme to build and install the "
+    "pytorch bindings for RNNT Loss, or use the provided docker "
+    "container that supports RNN-T loss."
+)
+
+
+@dataclass
+class RNNTLossConfig:
+    loss_name: str
+    lib_name: str
+    is_available: bool = False
+    installation_msg: str = ""
+    min_version: Optional[str] = None
+    force_float32: bool = True  # default True for now for all losses except graph-based
+
+
+# Resolved list of available RNNT losses
+RNNT_LOSS_RESOLVER = {
+    "warprnnt": RNNTLossConfig(
+        loss_name="warprnnt",
+        lib_name="warprnnt_pytorch",
+        is_available=WARP_RNNT_AVAILABLE,
+        installation_msg=WARP_RNNT_INSTALLATION_MESSAGE,
+        force_float32=True,
+    ),
+    "warprnnt_numba": RNNTLossConfig(
+        loss_name="warprnnt_numba",
+        lib_name="numba",
+        min_version='0.53.0',
+        is_available=NUMBA_RNNT_AVAILABLE,
+        installation_msg=NUMBA_INSTALLATION_MESSAGE,
+        force_float32=False,  # This is only temporarily false, will be dynamically updated during resolution
+    ),
+    "pytorch": RNNTLossConfig(
+        loss_name="pytorch",
+        lib_name="torch",
+        min_version='0.0',
+        is_available=True,
+        installation_msg="Pure Pytorch implementation of RNN-T loss. Slow and for debugging purposes only.",
+        force_float32=True,
+    ),
+    "multiblank_rnnt": RNNTLossConfig(
+        loss_name="multiblank_rnnt",
+        lib_name="numba",
+        min_version='0.53.0',
+        is_available=NUMBA_RNNT_AVAILABLE,
+        installation_msg=NUMBA_INSTALLATION_MESSAGE,
+        force_float32=True,
+    ),
+    "multiblank_rnnt_pytorch": RNNTLossConfig(
+        loss_name="pytorch",
+        lib_name="torch",
+        min_version='0.0',
+        is_available=True,
+        installation_msg="Pure Pytorch implementation of Multiblank RNN-T loss. Slow and for debugging purposes only.",
+        force_float32=True,
+    ),
+    "graph_w_transducer": RNNTLossConfig(
+        loss_name="graph_w_transducer",
+        lib_name="k2",
+        is_available=K2_AVAILABLE,
+        installation_msg=K2_INSTALLATION_MESSAGE,
+        force_float32=False,
+    ),
+    "graph_rnnt": RNNTLossConfig(
+        loss_name="graph_rnnt",
+        lib_name="k2",
+        is_available=K2_AVAILABLE,
+        installation_msg=K2_INSTALLATION_MESSAGE,
+        force_float32=False,
+    ),
+    "tdt": RNNTLossConfig(
+        loss_name="tdt",
+        lib_name="numba",
+        min_version='0.53.0',
+        is_available=NUMBA_RNNT_AVAILABLE,
+        installation_msg=NUMBA_INSTALLATION_MESSAGE,
+    ),
+    "tdt_pytorch": RNNTLossConfig(
+        loss_name="tdt_pytorch",
+        lib_name="torch",
+        min_version='0.0',
+        is_available=True,
+        installation_msg="Pure Pytorch implementation of TDT loss. Slow and for debugging purposes only.",
+    ),
+}
+
+RNNT_LOSS_RESOLVER['default'] = RNNT_LOSS_RESOLVER['warprnnt_numba']
+
+
+def _warn_unused_additional_kwargs(loss_name, kwargs):
+    if len(kwargs) > 0:
+        logging.warning(
+            f"Loss function `{loss_name}` was provided with following additional kwargs,\n"
+            f"however they were ignored as it is unused.\n"
+            f"{kwargs}"
+        )
+
+
+def _clean_kwargs(
+    loss_name: str, kwargs: Optional[Dict[str, Any]], init_method: Callable, ignore_params: Optional[Set[str]] = None
+) -> Dict[str, Any]:
+    """
+    Cleans kwargs for the given loss function. Warn if there are unused kwargs.
+
+    Args:
+        loss_name: name of the loss function
+        kwargs: kwargs to clean
+        init_method: LossClass.__init__ method
+        ignore_params: set of argument names for init_method to ignore
+
+    Returns:
+        only used kwargs for the given `init_method`
+    """
+    if not kwargs:
+        return {}
+    init_params = set(inspect.signature(init_method).parameters.keys()) - {"self"}
+    if ignore_params is not None:
+        init_params -= ignore_params
+    unused_kwargs = dict()
+    used_kwargs = dict()
+    for key, value in kwargs.items():
+        if key not in init_params:
+            unused_kwargs[key] = value
+        else:
+            used_kwargs[key] = value
+    if len(unused_kwargs) > 0:
+        _warn_unused_additional_kwargs(loss_name, unused_kwargs)
+    return used_kwargs
+
+
+def resolve_rnnt_default_loss_name() -> str:
+    return RNNT_LOSS_RESOLVER['default'].loss_name
+
+
+def resolve_rnnt_loss(loss_name: str, blank_idx: int, loss_kwargs: dict = None) -> torch.nn.Module:
+    loss_function_names = list(RNNT_LOSS_RESOLVER.keys())
+
+    if loss_name not in loss_function_names:
+        raise ValueError(
+            f"Provided `loss_name` {loss_name} not in list of available RNNT losses \n" f"{loss_function_names}"
+        )
+
+    all_available_losses = {name: config for name, config in RNNT_LOSS_RESOLVER.items() if config.is_available}
+
+    loss_config = RNNT_LOSS_RESOLVER[loss_name]  # type: RNNTLossConfig
+
+    # Re-raise import error with installation message
+    if not loss_config.is_available:
+        msg = (
+            f"Installed RNNT losses are : {list(all_available_losses.keys())}.\n"
+            f"****************************************************************\n"
+            f"To install the selected loss function, please follow the steps below:\n"
+            f"{loss_config.installation_msg}"
+        )
+        raise ImportError(msg)
+
+    # Library version check
+    if loss_config.min_version is not None:
+        ver_matched, msg = model_utils.check_lib_version(
+            loss_config.lib_name, checked_version=loss_config.min_version, operator=operator.ge
+        )
+
+        if ver_matched is False:
+            msg = (
+                f"{msg}\n"
+                f"****************************************************************\n"
+                f"To update the selected loss function, please follow the steps below:\n"
+                f"{loss_config.installation_msg}"
+            )
+            raise RuntimeError(msg)
+
+    # Resolve loss functions sequentially
+    loss_kwargs = {} if loss_kwargs is None else loss_kwargs
+
+    if isinstance(loss_kwargs, DictConfig):
+        loss_kwargs = OmegaConf.to_container(loss_kwargs, resolve=True)
+
+    # Get actual loss name for `default`
+    if loss_name == 'default':
+        loss_name = loss_config.loss_name
+
+    """
+    Resolve RNNT loss functions
+    """
+    if loss_name == 'warprnnt':
+        loss_func = warprnnt.RNNTLoss(blank=blank_idx, reduction='none')
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'warprnnt_numba':
+        # Update loss config's forced float32 flag if set to None
+        loss_config.force_float32 = not numba_utils.is_numba_cuda_fp16_supported()
+
+        fastemit_lambda = loss_kwargs.pop('fastemit_lambda', 0.0)
+        clamp = loss_kwargs.pop('clamp', -1.0)
+        loss_func = RNNTLossNumba(blank=blank_idx, reduction='none', fastemit_lambda=fastemit_lambda, clamp=clamp)
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'pytorch':
+        loss_func = RNNTLossPytorch(blank=blank_idx, reduction='none')
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'multiblank_rnnt':
+        fastemit_lambda = loss_kwargs.pop('fastemit_lambda', 0.0)
+        clamp = loss_kwargs.pop('clamp', -1.0)
+        big_blank_durations = loss_kwargs.pop('big_blank_durations', None)
+        sigma = loss_kwargs.pop('sigma', 0.0)
+        loss_func = MultiblankRNNTLossNumba(
+            blank=blank_idx,
+            big_blank_durations=big_blank_durations,
+            reduction='none',
+            fastemit_lambda=fastemit_lambda,
+            clamp=clamp,
+            sigma=sigma,
+        )
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'multiblank_rnnt_pytorch':
+        big_blank_durations = loss_kwargs.pop('big_blank_durations', None)
+        sigma = loss_kwargs.pop('sigma', 0.0)
+        loss_func = MultiblankRNNTLossPytorch(
+            blank=blank_idx, big_blank_durations=big_blank_durations, reduction='none', sigma=sigma
+        )
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'tdt':
+        fastemit_lambda = loss_kwargs.pop('fastemit_lambda', 0.0)
+        clamp = loss_kwargs.pop('clamp', -1.0)
+        durations = loss_kwargs.pop('durations', None)
+        sigma = loss_kwargs.pop('sigma', 0.0)
+        omega = loss_kwargs.pop('omega', 0.0)
+        loss_func = TDTLossNumba(
+            blank=blank_idx,
+            durations=durations,
+            reduction='none',
+            fastemit_lambda=fastemit_lambda,
+            clamp=clamp,
+            sigma=sigma,
+            omega=omega,
+        )
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == 'tdt_pytorch':
+        durations = loss_kwargs.pop('durations', None)
+        sigma = loss_kwargs.pop('sigma', 0.0)
+        loss_func = TDTLossPytorch(blank=blank_idx, durations=durations, reduction='none', sigma=sigma)
+        _warn_unused_additional_kwargs(loss_name, loss_kwargs)
+
+    elif loss_name == "graph_rnnt":
+        loss_kwargs = _clean_kwargs(loss_name, loss_kwargs, GraphRnntLoss.__init__, ignore_params={"blank"})
+        loss_func = GraphRnntLoss(blank=blank_idx, **loss_kwargs)
+    elif loss_name == "graph_w_transducer":
+        loss_kwargs = _clean_kwargs(loss_name, loss_kwargs, GraphWTransducerLoss.__init__, ignore_params={"blank"})
+        loss_func = GraphWTransducerLoss(blank=blank_idx, **loss_kwargs)
+    else:
+        raise ValueError(
+            f"Invalid value of `loss_name`: {loss_name}. Allowed loss names are :" f"{loss_function_names}"
+        )
+
+    return loss_func
+
+
+class RNNTLoss(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for CTCLoss.
+        """
+        return {
+            "log_probs": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
+            "targets": NeuralType(('B', 'T'), LabelsType()),
+            "input_lengths": NeuralType(tuple('B'), LengthsType()),
+            "target_lengths": NeuralType(tuple('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for CTCLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, num_classes, reduction: str = 'mean_batch', loss_name: str = "default", loss_kwargs=None):
+        """
+        RNN-T Loss function based on https://github.com/HawkAaron/warp-transducer.
+        Optionally, can utilize a numba implementation of the same loss without having to compile the loss,
+        albiet there is a small speed penalty for JIT numba compile.
+
+        Note:
+            Requires Numba 0.53.0 or later to be installed to use this loss function.
+
+        Losses can be selected via the config, and optionally be passed keyword arguments as follows.
+
+        Examples:
+            .. code-block:: yaml
+
+                model:  # RNNT Model config
+                    ...
+                    loss:
+                        loss_name: "warprnnt_numba"
+                        warprnnt_numba_kwargs:
+                            fastemit_lambda: 0.0
+
+        Warning:
+            In the case that GPU memory is exhausted in order to compute RNNTLoss, it might cause
+            a core dump at the cuda level with the following error message.
+
+            ```
+                ...
+                costs = costs.to(acts.device)
+            RuntimeError: CUDA error: an illegal memory access was encountered
+            terminate called after throwing an instance of 'c10::Error'
+            ```
+
+            Please kill all remaining python processes after this point, and use a smaller batch size
+            for train, validation and test sets so that CUDA memory is not exhausted.
+
+        Args:
+            num_classes: Number of target classes for the joint network to predict.
+                In all cases (conventional RNNT, multi-blank RNNT, and TDT model), this equals the token-id
+                for the standard "blank" symbol. In particular, say V is the number of non-blank tokens in
+                the vocabulary, then in the case of,
+                standard RNNT: num_classes = V
+                multiblank RNNT: num_classes = V + number-big-blanks (since we store big-blanks before
+                                 standard blank, and the standard blank is the last symbol in the vocab)
+                TDT: num_classes = V. Note, V here does not include any of the "duration outputs".
+
+            reduction: Type of reduction to perform on loss. Possible values are 
+                `mean_batch`, 'mean_volume`, `mean`, `sum` or None.
+                `None` will return a torch vector comprising the individual loss values of the batch.
+                `mean_batch` will average the losses in the batch
+                `mean` will divide each loss by the target length and then average
+                `mean_volume` will add up all the losses and divide by sum of target lengths
+
+            loss_name: String that is resolved into an RNNT loss function. Available list of losses
+                is ininitialized in `RNNT_LOSS_RESOLVER` dictionary.
+
+            loss_kwargs: Optional Dict of (str, value) pairs that are passed to the instantiated loss
+                function.
+        """
+        super(RNNTLoss, self).__init__()
+
+        if reduction not in [None, 'mean', 'sum', 'mean_batch', 'mean_volume']:
+            raise ValueError('`reduction` must be one of [mean, sum, mean_batch, mean_volume]')
+
+        self._blank = num_classes
+        self.reduction = reduction
+        self._loss = resolve_rnnt_loss(loss_name, blank_idx=self._blank, loss_kwargs=loss_kwargs)
+        self._force_float32 = RNNT_LOSS_RESOLVER[loss_name].force_float32
+        self._fp16_compat_checked = False
+
+    def reduce(self, losses, target_lengths):
+
+        if isinstance(losses, List):
+            losses = torch.cat(losses, 0)
+            target_lengths = torch.cat(target_lengths, 0)
+
+        if self.reduction == 'mean_batch':
+            losses = losses.mean()  # global batch size average
+        elif self.reduction == 'mean':
+            losses = torch.div(losses, target_lengths).mean()
+        elif self.reduction == 'sum':
+            losses = losses.sum()
+        elif self.reduction == 'mean_volume':
+            losses = losses.sum() / target_lengths.sum()  # same as above but longer samples weigh more
+
+        return losses
+
+    @typecheck()
+    def forward(self, log_probs, targets, input_lengths, target_lengths):
+        # Cast to int 64
+        targets = targets.long()
+        input_lengths = input_lengths.long()
+        target_lengths = target_lengths.long()
+
+        max_logit_len = input_lengths.max()
+        max_targets_len = target_lengths.max()
+
+        # Force cast joint to float32
+        if not self._force_float32 and numba_utils.is_numba_cuda_fp16_supported():
+            # Execute the kernel in fp16
+            pass
+        elif self._force_float32 and log_probs.dtype != torch.float32:
+            # Log just once if fp16 tensor was passed and fp16 Numba CUDA loss could not be used.
+            if log_probs.dtype == torch.float16 and not self._fp16_compat_checked:
+                _, reason = numba_utils.is_numba_cuda_fp16_supported(return_reason=True)
+                logging.warning(
+                    f"Provided RNNT Joint tensor is of dtype {log_probs.dtype}, but RNNT loss could not be calculated "
+                    f"in fp16 due to following reason stated below. Loss will be calculated in fp32. \n\n"
+                    f"{reason}",
+                    mode=logging_mode.ONCE,
+                )
+                self._fp16_compat_checked = True
+
+            # Upcast the activation tensor and compute loss and grads in fp32
+            logits_orig = log_probs
+            log_probs = log_probs.float()
+            del logits_orig  # save memory *before* computing the loss
+
+        # Ensure that shape mismatch does not occur due to padding
+        # Due to padding and subsequent downsampling, it may be possible that
+        # max sequence length computed does not match the actual max sequence length
+        # of the log_probs tensor, therefore we increment the input_lengths by the difference.
+        # This difference is generally small.
+        if log_probs.shape[1] != max_logit_len:
+            log_probs = log_probs.narrow(dim=1, start=0, length=max_logit_len).contiguous()
+
+        # Reduce transcript length to correct alignment if additional padding was applied.
+        # Transcript: [B, L] -> [B, L']; If L' < L
+        if not targets.is_contiguous():
+            targets = targets.contiguous()
+
+        if targets.shape[1] != max_targets_len:
+            targets = targets.narrow(dim=1, start=0, length=max_targets_len).contiguous()
+
+        # Temporarily override loss reduction
+        loss_reduction = self._loss.reduction
+        self._loss.reduction = None
+
+        # Compute RNNT loss
+        loss = self._loss(acts=log_probs, labels=targets, act_lens=input_lengths, label_lens=target_lengths)
+
+        # Loss reduction can be dynamic, so reset it after call
+        self._loss.reduction = loss_reduction
+
+        # reduce here using our own reduction function
+        if self.reduction is not None:
+            loss = self.reduce(loss, target_lengths)
+
+        # del new variables that may have been created
+        del (
+            log_probs,
+            targets,
+            input_lengths,
+            target_lengths,
+        )
+
+        return loss

nemo/collections/asr/losses/rnnt_pytorch.py

@@ -0,0 +1,374 @@
+# ! /usr/bin/python
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import List
+
+import torch
+
+from nemo.core.classes import Loss
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType
+
+
+class RNNTLossPytorch(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for CTCLoss.
+        """
+        return {
+            "acts": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
+            "labels": NeuralType(('B', 'T'), LabelsType()),
+            "act_lens": NeuralType(tuple('B'), LengthsType()),
+            "label_lens": NeuralType(tuple('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for CTCLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, blank, reduction):
+        super().__init__()
+        self.blank = blank
+        self.reduction = reduction
+
+    def forward(self, acts, labels, act_lens, label_lens):
+        # CPU patch for FP16
+        if not acts.is_cuda and acts.dtype == torch.float16:
+            acts = acts.float()
+
+        acts = torch.log_softmax(acts, -1)
+
+        forward_logprob = self.compute_forward_prob(acts, labels, act_lens, label_lens)
+        losses = -forward_logprob
+        if self.reduction == 'mean_batch':
+            losses = losses.mean()  # global batch size average
+        elif self.reduction == 'mean':
+            losses = torch.div(losses, label_lens).mean()
+        elif self.reduction == 'sum':
+            losses = losses.sum()
+        elif self.reduction == 'mean_volume':
+            losses = losses.sum() / label_lens.sum()  # same as above but longer samples weigh more
+
+        return losses
+
+    def compute_forward_prob(self, acts, labels, act_lens, label_lens):
+        B, T, U, _ = acts.shape
+
+        log_alpha = torch.zeros(B, T, U)
+        log_alpha = log_alpha.to(acts.device)
+
+        for t in range(T):
+            for u in range(U):
+                if u == 0:
+                    if t == 0:
+                        # this is the base case: (t=0, u=0) with log-alpha = 0.
+                        log_alpha[:, t, u] = 0.0
+                    else:
+                        # this is case for (t = 0, u > 0), reached by (t, u - 1)
+                        # emitting a blank symbol.
+                        log_alpha[:, t, u] = log_alpha[:, t - 1, u] + acts[:, t - 1, 0, self.blank]
+                else:
+                    if t == 0:
+                        # in case of (u > 0, t = 0), this is only reached from
+                        # (t, u - 1) with a label emission.
+                        gathered = torch.gather(
+                            acts[:, t, u - 1], dim=1, index=labels[:, u - 1].view(-1, 1).type(torch.int64)
+                        ).reshape(-1)
+                        log_alpha[:, t, u] = log_alpha[:, t, u - 1] + gathered.to(log_alpha.device)
+                    else:
+                        # here both t and u are > 0, this state is reachable
+                        # with two possibilities: (t - 1, u) with a blank emission
+                        # or (t, u - 1) with a label emission.
+                        log_alpha[:, t, u] = torch.logsumexp(
+                            torch.stack(
+                                [
+                                    log_alpha[:, t - 1, u] + acts[:, t - 1, u, self.blank],
+                                    log_alpha[:, t, u - 1]
+                                    + torch.gather(
+                                        acts[:, t, u - 1], dim=1, index=labels[:, u - 1].view(-1, 1).type(torch.int64)
+                                    ).reshape(-1),
+                                ]
+                            ),
+                            dim=0,
+                        )
+
+        log_probs = []
+        for b in range(B):
+            # here we need to add the final blank emission weights.
+            to_append = (
+                log_alpha[b, act_lens[b] - 1, label_lens[b]] + acts[b, act_lens[b] - 1, label_lens[b], self.blank]
+            )
+            log_probs.append(to_append)
+        log_prob = torch.stack(log_probs)
+
+        return log_prob
+
+
+class TDTLossPytorch(Loss):
+    """
+    Pure Python implementation of TDT loss (https://arxiv.org/pdf/2304.06795.pdf)
+    """
+
+    @property
+    def input_types(self):
+        """Input types definitions for CTCLoss.
+        """
+        return {
+            "acts": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
+            "labels": NeuralType(('B', 'T'), LabelsType()),
+            "act_lens": NeuralType(tuple('B'), LengthsType()),
+            "label_lens": NeuralType(tuple('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for CTCLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, blank: int, durations: List[int] = [], reduction: str = 'sum', sigma: float = 0.0):
+        super().__init__()
+        self.blank = blank
+        self.durations = durations
+        self.n_durations = len(durations)
+        self.reduction = reduction
+        self.sigma = sigma
+
+    def forward(self, acts, labels, act_lens, label_lens):
+        label_acts = acts[:, :, :, : -self.n_durations]
+        duration_acts = acts[:, :, :, -self.n_durations :]
+
+        # the - self.sigma here is for logit-undernormalization. Check the paper for details.
+        label_acts = torch.log_softmax(label_acts, -1) - self.sigma
+
+        duration_acts = torch.log_softmax(duration_acts, -1)
+
+        forward_logprob, _ = self.compute_forward_prob(label_acts, duration_acts, labels, act_lens, label_lens)
+        losses = -forward_logprob
+        if self.reduction == 'mean_batch':
+            losses = losses.mean()  # global batch size average
+        elif self.reduction == 'mean':
+            losses = torch.div(losses, label_lens).mean()
+        elif self.reduction == 'sum':
+            losses = losses.sum()
+        elif self.reduction == 'mean_volume':
+            losses = losses.sum() / label_lens.sum()  # same as above but longer samples weigh more
+
+        return losses
+
+    def logsumexp(self, a, b):
+        ret = torch.logsumexp(torch.stack([a, b]), dim=0)
+        return ret
+
+    def compute_forward_prob(self, acts, duration_acts, labels, act_lens, label_lens):
+        """This function implements Equation 7 in the TDT paper https://arxiv.org/pdf/2304.06795.pdf,
+        Simply put, for each alpha(t, u), it sums over the contribution from all incoming blank arcs and non-blank arcs.
+        """
+        B, T, U, _ = acts.shape
+
+        log_alpha = torch.zeros(B, T, U)
+        log_alpha = log_alpha.cuda()
+        for b in range(B):
+            for t in range(T):
+                for u in range(U):
+                    if u == 0:
+                        if t == 0:
+                            # both t and u are 0, this is the base case for alphas.
+                            log_alpha[b, t, u] = 0.0
+                        else:
+                            # u = 0 and t != 0: only considers blank emissions.
+                            log_alpha[b, t, u] = -1000.0
+                            for n, l in enumerate(self.durations):
+                                if (
+                                    t - l >= 0 and l > 0
+                                ):  # checking conditions for blank emission, l has to be at least 1
+                                    tmp = (
+                                        log_alpha[b, t - l, u]
+                                        + acts[b, t - l, u, self.blank]
+                                        + duration_acts[b, t - l, u, n]
+                                    )
+                                    log_alpha[b, t, u] = self.logsumexp(tmp, 1.0 * log_alpha[b, t, u])
+
+                    else:
+                        # u != 0 here, need to consider both blanks and non-blanks.
+                        log_alpha[b, t, u] = -1000.0
+                        for n, l in enumerate(self.durations):
+                            if t - l >= 0:
+                                if l > 0:  # for blank emissions. Need to ensure index is not out-of-bound.
+                                    tmp = (
+                                        log_alpha[b, t - l, u]
+                                        + acts[b, t - l, u, self.blank]
+                                        + duration_acts[b, t - l, u, n]
+                                    )
+                                    log_alpha[b, t, u] = self.logsumexp(tmp, 1.0 * log_alpha[b, t, u])
+
+                                # non-blank emissions.
+                                tmp = (
+                                    log_alpha[b, t - l, u - 1]
+                                    + acts[b, t - l, u - 1, labels[b, u - 1]]
+                                    + duration_acts[b, t - l, u - 1, n]
+                                )
+                                log_alpha[b, t, u] = self.logsumexp(tmp, 1.0 * log_alpha[b, t, u])
+
+        log_probs = []
+        for b in range(B):
+            tt = torch.Tensor([-1000.0]).cuda()[0]
+
+            # need to loop over all possible ways that blank with different durations contributes to the final loss.
+            for n, l in enumerate(self.durations):
+                if act_lens[b] - l >= 0 and l > 0:
+                    bb = (
+                        log_alpha[b, act_lens[b] - l, label_lens[b]]
+                        + acts[b, act_lens[b] - l, label_lens[b], self.blank]
+                        + duration_acts[b, act_lens[b] - l, label_lens[b], n]
+                    )
+
+                    tt = self.logsumexp(bb, 1.0 * tt)
+
+            log_probs.append(tt)
+
+        log_prob = torch.stack(log_probs)
+
+        return log_prob, log_alpha
+
+
+class MultiblankRNNTLossPytorch(Loss):
+    """
+    Pure Python implementation of multi-blank transducer loss (https://arxiv.org/pdf/2211.03541.pdf)
+    """
+
+    @property
+    def input_types(self):
+        """Input types definitions for CTCLoss.
+        """
+        return {
+            "acts": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
+            "labels": NeuralType(('B', 'T'), LabelsType()),
+            "act_lens": NeuralType(tuple('B'), LengthsType()),
+            "label_lens": NeuralType(tuple('B'), LengthsType()),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for CTCLoss.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    def __init__(self, blank, big_blank_durations, reduction: str = "sum", sigma: float = 0.0):
+        super().__init__()
+        self.blank = blank
+        self.big_blank_durations = big_blank_durations
+        self.reduction = reduction
+        self.sigma = sigma
+
+    def forward(self, acts, labels, act_lens, label_lens):
+        acts = torch.log_softmax(acts, -1) - self.sigma
+        forward_logprob, _ = self.compute_forward_prob(acts, labels, act_lens, label_lens)
+
+        losses = -forward_logprob
+        if self.reduction == 'mean_batch':
+            losses = losses.mean()  # global batch size average
+        elif self.reduction == 'mean':
+            losses = torch.div(losses, label_lens).mean()
+        elif self.reduction == 'sum':
+            losses = losses.sum()
+        elif self.reduction == 'mean_volume':
+            losses = losses.sum() / label_lens.sum()  # same as above but longer samples weigh more
+
+        return losses
+
+    def compute_forward_prob(self, acts, labels, act_lens, label_lens):
+        B, T, U, _ = acts.shape
+
+        log_alpha = torch.zeros(B, T, U, device=acts.device)
+        for t in range(T):
+            for u in range(U):
+                if u == 0:
+                    if t == 0:
+                        # this is the base case: (t=0, u=0) with log-alpha = 0.
+                        log_alpha[:, t, u] = 0.0
+                    else:
+                        # this is case for (t = 0, u > 0), reached by (t, u - d)
+                        # emitting a blank symbol of duration d.
+                        log_alpha[:, t, u] = log_alpha[:, t - 1, u] + acts[:, t - 1, 0, self.blank]
+                        for i, d in enumerate(self.big_blank_durations):
+                            if t >= d:
+                                tt = log_alpha[:, t - d, u] + acts[:, t - d, 0, self.blank - 1 - i]
+                                log_alpha[:, t, u] = torch.logsumexp(
+                                    torch.stack([1.0 * log_alpha[:, t, u], tt]), dim=0
+                                )
+
+                else:
+                    if t == 0:
+                        # in case of (u > 0, t = 0), this is only reached from
+                        # (t, u - 1) with a label emission.
+                        gathered = torch.gather(
+                            acts[:, t, u - 1], dim=1, index=labels[:, u - 1].view(-1, 1).type(torch.int64)
+                        ).reshape(-1)
+                        log_alpha[:, t, u] = log_alpha[:, t, u - 1] + gathered
+                    else:
+                        # here both t and u are > 0, this state is reachable
+                        # with two possibilities: (t - d, u) with emission of
+                        # blank with duration d, or (t, u - 1) with a label emission.
+
+                        # first we take care of the standard blank.
+                        log_alpha[:, t, u] = torch.logsumexp(
+                            torch.stack(
+                                [
+                                    log_alpha[:, t - 1, u] + acts[:, t - 1, u, self.blank],
+                                    log_alpha[:, t, u - 1]
+                                    + torch.gather(
+                                        acts[:, t, u - 1], dim=1, index=labels[:, u - 1].view(-1, 1).type(torch.int64)
+                                    ).reshape(-1),
+                                ]
+                            ),
+                            dim=0,
+                        )
+
+                        # now we go over all big blanks. They need to be considered if current t >= blank duration d.
+                        for i, d in enumerate(self.big_blank_durations):
+                            if t >= d:
+                                tt = log_alpha[:, t - d, u] + acts[:, t - d, u, self.blank - 1 - i]
+                                log_alpha[:, t, u] = torch.logsumexp(
+                                    torch.stack([1.0 * log_alpha[:, t, u], tt]), dim=0
+                                )
+
+        log_probs = []
+        for b in range(B):
+            # here we need to add the final blank emission weights, which needs
+            # to consider all possible blank durations.
+            to_append = (
+                log_alpha[b, act_lens[b] - 1, label_lens[b]] + acts[b, act_lens[b] - 1, label_lens[b], self.blank]
+            )
+
+            for i, d in enumerate(self.big_blank_durations):
+                if act_lens[b] >= d:
+                    tt = (
+                        log_alpha[b, act_lens[b] - d, label_lens[b]]
+                        + acts[b, act_lens[b] - d, label_lens[b], self.blank - 1 - i]
+                    )
+                    to_append = torch.logsumexp(torch.stack([1.0 * to_append, tt]), dim=0)
+
+            log_probs.append(to_append)
+        log_prob = torch.stack(log_probs)
+
+        return log_prob, log_alpha

nemo/collections/asr/losses/ssl_losses/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr.losses.ssl_losses.contrastive import ContrastiveLoss

nemo/collections/asr/losses/ssl_losses/contrastive.py

@@ -0,0 +1,304 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from math import ceil
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from nemo.core import Loss, typecheck
+from nemo.core.neural_types import AcousticEncodedRepresentation, LengthsType, LossType, NeuralType, SpectrogramType
+
+__all__ = ["ContrastiveLoss"]
+
+
+class ContrastiveLoss(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for Contrastive."""
+        return {
+            "spectrograms": NeuralType(("B", "D", "T"), SpectrogramType()),
+            "spec_masks": NeuralType(("B", "D", "T"), SpectrogramType()),
+            "decoder_outputs": NeuralType(("B", "T", "D"), AcousticEncodedRepresentation()),
+            "decoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for Contrastive.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    @property
+    def needs_labels(self):
+        return False
+
+    def __init__(
+        self,
+        in_dim: int,
+        proj_dim: int = 128,
+        combine_time_steps: int = 1,
+        num_negatives: int = 100,
+        quantized_targets: bool = False,
+        codebook_size: int = 320,
+        prob_ppl_weight: float = 0.1,
+        logit_temp: float = 0.1,
+        reduce: str = "sum",
+        sample_from_same_utterance_only: bool = True,
+        sample_from_non_masked: bool = False,
+        sample_from_codebook: bool = False,
+        group_loss: bool = False,
+        num_groups: int = 2,
+        quantizer_temp_start: float = 2,
+        quantizer_temp_min: float = 0.5,
+        quantizer_temp_decay: float = 0.999995,
+        mask_threshold: float = 0.8,
+        store_ids: bool = True,
+        reduce_ids: bool = False,
+        multiplier: float = 16.0,
+    ):
+        """
+        Loss function representing the contrastive task of identifying the true latent speech representation of
+        the masked spectrogram steps from a set of sampled distractors.
+
+        Args:
+            in_dim: Number of spectrogram channels.
+            proj_dim: Number of channels in the model outputs.
+            combine_time_steps: How many time steps should be combined into a single representation.
+            num_negatives: Number of sampled negatives for each target.
+            quantized_targets: Bool that determines if the targets should be quantized.
+            codebook_size: Number of vectors in the codebook per group.
+            prob_ppl_weight: Float multiplier on the perplexity loss for target quantization.
+            logit_temp: Float temperature for normalizing logits.
+            reduce: String representing the type of reduction used for cross entropy.
+            sample_from_same_utterance_only: Bool that determines if negatives should be sampled only from same utterance.
+            sample_from_non_masked: Bool that determines if negatives should be sampled from non-masked steps of the spectrogram.
+            sample_from_codebook: Bool that determines if negatives should be sampled from entire codebook.
+            group_loss: Bool that determines if loss should be computed separately for each group in the quantizer codebook.
+            num_groups: Number of groups in the quantizer codebook.
+            quantizer_temp_start: Starting temperature in quantizer.
+            quantizer_temp_min: Minimum temperature in quantizer.
+            quantizer_temp_decay: Decay rate of quantizer temperature per global step.
+            mask_threshold: Float threshold for determining if a time step of the spectrogram is masked based on percent of masked channels.
+            store_ids: Bool that determines if the quantizer ids will be stored to be potentially used by other losses.
+            reduce_ids: Bool that determines if we convert any sequence of consecutive equivalent ids to a single occurence of that id.
+            multiplier: Float multipler on final loss
+        """
+
+        super().__init__()
+        quantizer_temp = (quantizer_temp_start, quantizer_temp_min, quantizer_temp_decay)
+        self.quantized_targets = quantized_targets
+        self.num_negatives = num_negatives
+        self.prob_ppl_weight = prob_ppl_weight
+        if self.quantized_targets:
+            quantizer_cfg = {
+                "_target_": "nemo.collections.asr.parts.submodules.ssl_quantizers.GumbelVectorQuantizer",
+                "dim": in_dim * combine_time_steps,
+                "vq_dim": proj_dim,
+                "num_vars": codebook_size,
+                "groups": num_groups,
+                "temp": quantizer_temp,
+                "combine_groups": True,
+                "time_first": True,
+            }
+            self.quantizer = ContrastiveLoss.from_config_dict(quantizer_cfg)
+        self.prob_ppl_weight = prob_ppl_weight
+        self.logit_temp = logit_temp
+        self.reduce = reduce
+        self.combine_time_steps = combine_time_steps
+        self.sample_from_same_utterance_only = sample_from_same_utterance_only
+        self.sample_from_non_masked = sample_from_non_masked
+        self.sample_from_codebook = sample_from_codebook
+        self.group_loss = group_loss
+        self.mask_threshold = mask_threshold
+        self.multiplier = multiplier
+
+        self.store_ids = store_ids
+        self.reduce_ids = reduce_ids
+
+        if not self.quantized_targets:
+            self.target_proj = nn.Linear(in_dim * combine_time_steps, proj_dim)
+
+    def sample_negatives(self, y, num):
+        # y - T'xBxC or T'xC
+
+        high = y.shape[0]
+        neg_idxs = torch.multinomial(torch.ones((num, high), device=y.device), self.num_negatives)
+
+        negs = y[neg_idxs.view(-1)]
+        negs = negs.view((num, self.num_negatives) + y.shape[1:])
+        negs = negs.transpose(0, 1)
+        # negs - NxT'xBxC or NxT'xC
+
+        return negs, neg_idxs
+
+    @typecheck()
+    def forward(self, spectrograms, spec_masks, decoder_outputs, decoder_lengths=None):
+        targets = spectrograms.transpose(-2, -1)
+        masks = spec_masks.transpose(-2, -1)
+        # BxTxC
+        diff = int(ceil(targets.shape[1] / decoder_outputs.shape[1]) * decoder_outputs.shape[1]) - targets.shape[1]
+
+        if diff > 0:
+            targets = F.pad(targets, (0, 0, 0, diff))
+            masks = F.pad(masks, (0, 0, 0, diff))
+
+        targets = targets.reshape(targets.shape[0], decoder_outputs.shape[1], -1)
+        masks = masks.reshape(targets.shape[0], decoder_outputs.shape[1], -1)
+
+        if self.quantized_targets:
+            if self.store_ids:
+                # store ids for use by other losses
+                targets, prob_ppl_loss, cur_codebook_temp, self.target_ids = self.quantizer(targets, return_ids=True)
+
+                if self.reduce_ids:
+                    # reduce consecutive equivalent ids to a single occurence
+                    _, indices = torch.unique_consecutive(self.target_ids, return_inverse=True)
+                    indices -= indices.min(dim=1, keepdims=True)[0]
+                    reduced_ids = torch.zeros_like(self.target_ids)
+                    reduced_ids = reduced_ids.scatter_(1, indices, self.target_ids)
+                    reduced_lens = indices.max(dim=-1)[0] + 1
+
+                    self.target_ids = reduced_ids.narrow(1, 0, reduced_lens.max())
+                    self.target_lengths = reduced_lens
+
+                else:
+                    self.target_lengths = None
+
+            else:
+                targets, prob_ppl_loss, cur_codebook_temp = self.quantizer(targets)
+        else:
+            targets = self.target_proj(targets)
+
+        if self.sample_from_same_utterance_only:
+            bs = decoder_outputs.shape[0]
+            masks = masks.mean(-1) > self.mask_threshold
+            out_masked_only = decoder_outputs[masks]
+            targets_masked_only = targets[masks]
+            out_masked_only = out_masked_only.reshape(bs, -1, out_masked_only.shape[-1])
+            targets_masked_only = targets_masked_only.reshape(bs, -1, targets_masked_only.shape[-1])
+
+            # BxT'xC
+            # number of masked time steps to predict (T')
+            # -> T'xBxC
+
+            out_masked_only = out_masked_only.transpose(0, 1)
+            targets_masked_only = targets_masked_only.transpose(0, 1)
+            # -> T'xBxC
+
+            if self.sample_from_non_masked:
+                # sample from all steps in utterance
+                negatives, _ = self.sample_negatives(
+                    targets.transpose(0, 1),
+                    targets_masked_only.size(0),  # TxBxC  # T'
+                )
+            else:
+                # only sample from masked steps in utterance
+                negatives, _ = self.sample_negatives(targets_masked_only, targets_masked_only.size(0))  # T'xBxC  # T'
+            # NxT'xBxC
+
+            out_masked_only = out_masked_only.reshape(-1, out_masked_only.shape[-1])
+            targets_masked_only = targets_masked_only.reshape(-1, targets_masked_only.shape[-1])
+            negatives = negatives.reshape(self.num_negatives, -1, negatives.shape[-1])
+
+            # T'BxC and NxT'BxC
+
+        else:
+            masks = masks.mean(-1) > self.mask_threshold
+            out_masked_only = decoder_outputs[masks]
+            targets_masked_only = targets[masks]
+
+            # T'xC
+            # number of masked time steps to predict (T')
+
+            if self.group_loss:
+                num_groups = self.quantizer.groups
+                negatives = self.quantizer.vars.reshape(num_groups, self.quantizer.num_vars, -1)
+                # GxNx(C//G)
+                negatives = negatives.transpose(0, 1)
+                # NxGx(C//G)
+                negatives = negatives.unsqueeze(1).expand(-1, out_masked_only.shape[0], -1, -1)
+                # NxT'xGx(C//G)
+                negatives = negatives.reshape(negatives.shape[0], -1, negatives.shape[-1])
+                # NxT'Gx(C//G)
+
+                out_masked_only = out_masked_only.reshape(-1, out_masked_only.shape[-1] // num_groups)
+                targets_masked_only = targets_masked_only.reshape(-1, targets_masked_only.shape[-1] // num_groups)
+                # T'Gx(C//G)
+            elif self.sample_from_codebook:
+                # sample from the full codebook
+                negatives = self.quantizer.sample_from_codebook(self.num_negatives, targets_masked_only.size(0))
+            elif self.sample_from_non_masked:
+                # sample from all steps in batch
+                negatives, _ = self.sample_negatives(
+                    targets.reshape(targets.shape[0] * targets.shape[1], -1),
+                    targets_masked_only.size(0),  # BTxC
+                )  # T'
+            else:
+                # only sample from masked steps
+                negatives, _ = self.sample_negatives(targets_masked_only, targets_masked_only.size(0))  # T'xC  # T'
+                # NxT'xC
+
+        # Calculate similarity between outputs and all targets
+        similarity_scores = self._calculate_similarity(out_masked_only, negatives, targets_masked_only)
+        # (1+N)xT'
+        # cosine similarity of outs with targets + N negatives
+
+        # Create targets of size T
+        similarity_targets = decoder_outputs.new_zeros(similarity_scores.size(1), dtype=torch.long)
+        # T'
+        # targets are 0, since it's the first, followed by N sampled negatives
+
+        # Transpose similarity scores to TxF for loss
+        similarity_scores = similarity_scores.transpose(0, 1)
+        # T'x(1+N)
+
+        loss = F.cross_entropy(similarity_scores, similarity_targets, reduction=self.reduce)
+
+        sample_size = similarity_targets.numel()
+
+        if self.prob_ppl_weight != 0 and self.quantized_targets:
+            prob_ppl_loss = self.prob_ppl_weight * prob_ppl_loss * sample_size
+            loss += prob_ppl_loss
+
+        if not isinstance(loss, torch.Tensor):
+            loss = torch.Tensor([0]).to(device=decoder_outputs.device)
+
+        batch_size = spectrograms.shape[0]
+        loss *= self.multiplier / batch_size
+
+        return loss
+
+    def _calculate_similarity(self, logits, negatives, targets):
+        neg_is_pos = (targets == negatives).all(-1)
+        # NxT' - true where the negative is actually the positive
+        targets = targets.unsqueeze(0)
+        # 1xT'xC
+        targets = torch.cat([targets, negatives], dim=0)
+        # (1+N)xT'XC
+        logits = torch.cosine_similarity(
+            logits.float().unsqueeze(0).expand(targets.shape[0], -1, -1), targets.float(), dim=-1
+        ).type_as(logits)
+        # (1+N)xT'
+        logits /= self.logit_temp
+        if neg_is_pos.any():
+            logits[1:][neg_is_pos] = float("-inf")
+        return logits
+
+    def set_num_updates(self, num_updates):
+        if self.quantized_targets:
+            self.quantizer.set_num_updates(num_updates)

nemo/collections/asr/losses/ssl_losses/ctc.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr.losses import CTCLoss
+from nemo.core import Loss, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LossType, NeuralType, SpectrogramType, VoidType
+
+__all__ = ["CTCLossForSSL"]
+
+
+class CTCLossForSSL(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for Contrastive.
+        """
+        return {
+            "spec_masks": NeuralType(("B", "D", "T"), SpectrogramType()),
+            "decoder_outputs": NeuralType(("B", "T", "D"), VoidType()),
+            "targets": NeuralType(('B', 'T'), LabelsType()),
+            "decoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+            "target_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for Contrastive.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    @property
+    def needs_labels(self):
+        return True
+
+    def __init__(self, num_classes, zero_infinity=True, reduction='mean_batch'):
+        super().__init__()
+        self.loss = CTCLoss(num_classes=num_classes, reduction=reduction, zero_infinity=zero_infinity)
+
+    @typecheck()
+    def forward(self, spec_masks, decoder_outputs, targets, decoder_lengths=None, target_lengths=None):
+        loss = self.loss(
+            log_probs=decoder_outputs, targets=targets, input_lengths=decoder_lengths, target_lengths=target_lengths
+        )
+
+        return loss

nemo/collections/asr/losses/ssl_losses/mlm.py

@@ -0,0 +1,138 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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 torch
+import torch.nn.functional as F
+from torch import nn
+
+from nemo.core import Loss, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType, SpectrogramType
+
+__all__ = ["MLMLoss"]
+
+
+class MLMLoss(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for Contrastive."""
+        return {
+            "spec_masks": NeuralType(("B", "D", "T"), SpectrogramType(), optional=True),
+            "decoder_outputs": NeuralType(("B", "T", "D"), LogprobsType()),
+            "targets": NeuralType(('B', 'T'), LabelsType()),
+            "decoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+            "target_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+            "masks": NeuralType(("B", "D", "T"), SpectrogramType(), optional=True),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for Contrastive.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    @property
+    def needs_labels(self):
+        return True
+
+    def __init__(
+        self,
+        combine_time_steps: int = 1,
+        mask_threshold: float = 0.8,
+    ):
+        super().__init__()
+        self.nll_loss = nn.NLLLoss()
+        self.combine_time_steps = combine_time_steps
+        self.mask_threshold = mask_threshold
+
+    @typecheck()
+    def forward(
+        self, decoder_outputs, targets, decoder_lengths=None, target_lengths=None, spec_masks=None, masks=None
+    ):
+
+        if masks is None:
+            masks = spec_masks
+
+        # B,D,T -> B,T,D
+        masks = masks.transpose(1, 2)
+
+        masks = masks.reshape(masks.shape[0], masks.shape[1] // self.combine_time_steps, -1)
+        masks = masks.mean(-1) > self.mask_threshold
+
+        out_masked_only = decoder_outputs[masks]
+        targets = F.pad(targets, (0, masks.shape[-1] - targets.shape[-1]))
+        targets_masked_only = targets[masks]
+
+        loss = self.nll_loss(out_masked_only, targets_masked_only)
+        loss = torch.mean(loss)
+
+        return loss
+
+
+class MultiMLMLoss(Loss):
+    """
+    Masked language model loss for multiple decoders, where cross-entropy loss is applied separately on each decoder.
+    This loss can be used with `nemo.collections.asr.modules.ssl_modules.MultiSoftmaxDecoder` to train a model with multiple targets per frame.
+    Reference: https://arxiv.org/abs/2202.01855
+    """
+
+    @property
+    def input_types(self):
+        if self.squeeze_single and self.num_decoders == 1:
+            decoder_outputs = NeuralType(("B", "T", "C"), LogprobsType())
+            targets = NeuralType(('B', 'T'), LabelsType())
+        else:
+            decoder_outputs = NeuralType(("B", "T", "C", "H"), LogprobsType())
+            targets = NeuralType(("B", "T", "H"), LabelsType())
+        return {
+            "masks": NeuralType(("B", "D", "T"), SpectrogramType()),
+            "decoder_outputs": decoder_outputs,
+            "targets": targets,
+            "decoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+            "target_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    def __init__(
+        self,
+        combine_time_steps: int = 1,
+        mask_threshold: float = 0.8,
+        num_decoders: int = 1,
+        squeeze_single: bool = False,
+    ):
+        super().__init__()
+        self.num_decoders = num_decoders
+        self.squeeze_single = squeeze_single
+        self.mlm_loss = MLMLoss(combine_time_steps, mask_threshold)
+
+    @typecheck()
+    def forward(self, masks, decoder_outputs, targets, decoder_lengths=None, target_lengths=None):
+        if self.squeeze_single and self.num_decoders == 1:
+            return self.mlm_loss(
+                spec_masks=masks,
+                decoder_outputs=decoder_outputs,
+                targets=targets,
+                decoder_lengths=decoder_lengths,
+                target_lengths=target_lengths,
+            )
+        loss = 0.0
+        for i in range(self.num_decoders):
+            loss += self.mlm_loss(
+                spec_masks=masks,
+                decoder_outputs=decoder_outputs[:, :, :, i],
+                targets=targets[:, :, i],
+                decoder_lengths=decoder_lengths,
+                target_lengths=target_lengths,
+            )
+        return loss / self.num_decoders

nemo/collections/asr/losses/ssl_losses/rnnt.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr.losses.rnnt import RNNTLoss
+from nemo.core import Loss, typecheck
+from nemo.core.neural_types import LabelsType, LengthsType, LogprobsType, LossType, NeuralType, SpectrogramType
+
+__all__ = ["RNNTLossForSSL"]
+
+
+class RNNTLossForSSL(Loss):
+    @property
+    def input_types(self):
+        """Input types definitions for Contrastive.
+        """
+        return {
+            "spec_masks": NeuralType(("B", "D", "T"), SpectrogramType()),
+            "decoder_outputs": NeuralType(('B', 'T', 'T', 'D'), LogprobsType()),
+            "targets": NeuralType(('B', 'T'), LabelsType()),
+            "decoder_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+            "target_lengths": NeuralType(tuple('B'), LengthsType(), optional=True),
+        }
+
+    @property
+    def output_types(self):
+        """Output types definitions for Contrastive.
+        loss:
+            NeuralType(None)
+        """
+        return {"loss": NeuralType(elements_type=LossType())}
+
+    @property
+    def needs_labels(self):
+        return True
+
+    def __init__(self, num_classes):
+        super().__init__()
+        self.loss = RNNTLoss(num_classes=num_classes)
+
+    @typecheck()
+    def forward(self, spec_masks, decoder_outputs, targets, decoder_lengths=None, target_lengths=None):
+
+        loss = self.loss(
+            log_probs=decoder_outputs, targets=targets, input_lengths=decoder_lengths, target_lengths=target_lengths
+        )
+
+        return loss

nemo/collections/asr/metrics/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from nemo.collections.asr.metrics.bleu import BLEU
+from nemo.collections.asr.metrics.wer import WER

nemo/collections/asr/metrics/bleu.py

@@ -0,0 +1,212 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# 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.
+
+from typing import Literal, Optional, Sequence, Union
+
+import torch
+from torchmetrics.functional.text.bleu import _bleu_score_compute
+from torchmetrics.text import SacreBLEUScore
+
+from nemo.collections.asr.parts.submodules.ctc_decoding import AbstractCTCDecoding
+from nemo.collections.asr.parts.submodules.multitask_decoding import AbstractMultiTaskDecoding
+from nemo.collections.asr.parts.submodules.rnnt_decoding import AbstractRNNTDecoding
+from nemo.utils import logging
+
+__all__ = ['BLEU']
+
+
+def move_dimension_to_the_front(tensor, dim_index):
+    all_dims = list(range(tensor.ndim))
+    return tensor.permute(*([dim_index] + all_dims[:dim_index] + all_dims[dim_index + 1 :]))
+
+
+# TODO: Add documentation
+class BLEU(SacreBLEUScore):
+    """
+    This metric computes numerator, denominator, hypotheses lengths, and target lengths for Overall Bilingual Evaluation Understudy (BLEU)
+    between prediction and reference texts. When doing distributed training/evaluation the result of
+    ``res=BLEU.(predictions, predictions_lengths, targets, target_lengths)``
+    calls will be all-reduced between all workers using SUM operations.
+
+    If used with PytorchLightning LightningModule, include bleu_num bleur_den, bleu_pred_len, and bleu_target_len values inside
+    validation_step results. Then aggregate (sum) then at the end of validation epoch to correctly compute validation BLEUR.
+
+    Example:
+        def validation_step(self, batch, batch_idx):
+            ...
+            bleu_values = self.bleu(predictions, predictions_len, transcript, transcript_len)
+            self.val_outputs = {'val_loss': loss_value, **bleu_values}
+            return self.val_outputs
+
+        def on_validation_epoch_end(self):
+            ...
+            bleu_num = torch.stack([x['val_wer_num'] for x in self.val_outputs]).sum()
+            bleu_denom = torch.stack([x['val_wer_denom'] for x in self.val_outputs]).sum()
+            bleu_num = torch.stack([x[f"val_bleu_num"] for x in outputs]).sum(dim=0)
+            bleu_denom = torch.stack([x[f"val_bleu_denom"] for x in outputs]).sum(dim=0)
+
+            val_bleu = {"val_bleu": self.bleu._compute_bleu(bleu_pred_len, bleu_target_len, bleu_num, bleu_denom)}
+            tensorboard_logs.update(val_bleu)
+
+            self.val_outputs.clear()  # free memory
+            return {'val_loss': val_loss_mean, 'log': tensorboard_logs}
+
+    Args:
+        decoding: An instance of CTCDecoding, RNNTDecoding, or MultiTaskDecoding.
+        tokenize: Desired tokenizer for BLEU evaluation. (Depending on language, this will drastically affect BLEU score.)
+        n_gram: Maximum number of n_grams to compute BLEU values over. Max: 4.
+        lowercase: Whether to lowercase all inputs.
+        weights: List of float values to weight each n_gram score.
+        log_prediction: Whether to log a single decoded sample per call.
+        batch_dim_index: Index corresponding to batch dimension. (For RNNT.)
+        dist_dync_on_step: Whether to perform reduction on forward pass of metric.
+
+    Returns:
+        res: a tuple of 3 zero dimensional float32 ``torch.Tensor` objects: a WER score, a sum of Levenstein's
+            distances for all prediction - reference pairs, total number of words in all references.
+    """
+
+    full_state_update: bool = True
+
+    def __init__(
+        self,
+        decoding: Union[AbstractCTCDecoding, AbstractRNNTDecoding, AbstractMultiTaskDecoding],
+        tokenize: Literal["none", "13a", "zh", "intl", "char"] = "13a",
+        n_gram: int = 4,
+        lowercase: bool = False,
+        weights: Optional[Sequence[float]] = None,
+        smooth: bool = False,
+        log_prediction=True,
+        batch_dim_index=0,
+        dist_sync_on_step=False,
+    ):
+        super().__init__(
+            tokenize=tokenize,
+            n_gram=n_gram,
+            lowercase=lowercase,
+            weights=weights,
+            smooth=smooth,
+            dist_sync_on_step=dist_sync_on_step,
+        )
+        self.decoding = decoding
+        self.decode = None
+        if isinstance(self.decoding, AbstractRNNTDecoding):
+            self.decode = lambda predictions, predictions_lengths, predictions_mask, input_ids, targets: self.decoding.rnnt_decoder_predictions_tensor(
+                encoder_output=predictions, encoded_lengths=predictions_lengths
+            )
+        elif isinstance(self.decoding, AbstractCTCDecoding):
+            self.decode = lambda predictions, predictions_lengths, predictions_mask, input_ids, targets: self.decoding.ctc_decoder_predictions_tensor(
+                decoder_outputs=predictions,
+                decoder_lengths=predictions_lengths,
+                fold_consecutive=self.fold_consecutive,
+            )
+        elif isinstance(self.decoding, AbstractMultiTaskDecoding):
+            self.decode = lambda predictions, prediction_lengths, predictions_mask, input_ids, targets: self.decoding.decode_predictions_tensor(
+                encoder_hidden_states=predictions,
+                encoder_input_mask=predictions_mask,
+                decoder_input_ids=input_ids,
+                return_hypotheses=False,
+            )
+        else:
+            raise TypeError(f"WER metric does not support decoding of type {type(self.decoding)}")
+
+        self.tokenize = tokenize
+        self.log_prediction = log_prediction
+        self.batch_dim_index = batch_dim_index
+
+    def update(
+        self,
+        predictions: torch.Tensor,
+        predictions_lengths: torch.Tensor,
+        targets: torch.Tensor,
+        targets_lengths: torch.Tensor,
+        predictions_mask: Optional[torch.Tensor] = None,
+        input_ids: Optional[torch.Tensor] = None,
+    ):
+        """
+        Updates metric state.
+        Args:
+            predictions: an integer torch.Tensor of shape ``[Batch, Time, {Vocabulary}]`` (if ``batch_dim_index == 0``) or
+                ``[Time, Batch]`` (if ``batch_dim_index == 1``)
+            predictions_lengths: an integer torch.Tensor of shape ``[Batch]``
+            targets: an integer torch.Tensor of shape ``[Batch, Time]`` (if ``batch_dim_index == 0``) or
+                ``[Time, Batch]`` (if ``batch_dim_index == 1``)
+            target_lengths: an integer torch.Tensor of shape ``[Batch]``
+            predictions_mask: a bool torch.Tensor of shape ``[Batch, Time]`` (if ``batch_dim_index == 0``) or
+                ``[Time, Batch]`` (if ``batch_dim_index == 1``). Required for MultiTaskDecoding.
+            input_ids: an int torch.Tensor of shape ``[Batch, Time]`` (if ``batch_dim_index == 0``) or
+                ``[Time, Batch]`` (if ``batch_dim_index == 1``). Required for MultiTaskDecoding.
+        """
+        references = []
+        with torch.no_grad():
+            tgt_lenths_cpu_tensor = targets_lengths.long().cpu()
+            targets_cpu_tensor = targets.long().cpu()
+            # check batch_dim_index is first dim
+            if self.batch_dim_index != 0:
+                targets_cpu_tensor = move_dimension_to_the_front(targets_cpu_tensor, self.batch_dim_index)
+            # iterate over batch
+            for ind in range(targets_cpu_tensor.shape[0]):
+                tgt_len = tgt_lenths_cpu_tensor[ind].item()
+                target = targets_cpu_tensor[ind][:tgt_len].numpy().tolist()
+                reference = self.decoding.decode_tokens_to_str(target)
+                references.append(reference)
+            hypotheses = self.decode(predictions, predictions_lengths, predictions_mask, input_ids, targets)
+
+        if self.log_prediction:
+            logging.info("\n")
+            logging.info(f"reference:{references[0]}")
+            logging.info(f"predicted:{hypotheses[0]}")
+
+        super().update(
+            [h.text for h in hypotheses], [references]
+        )  # Note: [references] since BLEU allows multiple references.
+
+    def compute(self, return_all_metrics=True, prefix="", suffix=""):
+        """
+        Returns BLEU values and component metrics.
+
+        Args:
+            return_all_metrics: bool flag. On True, BLEU and composite metrics returned. If False, returns
+                only BLEU. Default: True.
+            prefix: str to prepend to metric value keys.
+            suffix: str to append to metric value keys.
+
+        Returns:
+            Dict: key-value pairs of BLEU metrics and values. Keys are prepended and appended with prefix
+                and suffix flags, respectively.
+        """
+        bleu = super().compute()
+        if return_all_metrics:
+            return {
+                f"{prefix}bleu{suffix}": bleu,
+                f"{prefix}bleu_pred_len{suffix}": self.preds_len.detach().float(),
+                f"{prefix}bleu_target_len{suffix}": self.target_len.detach().float(),
+                f"{prefix}bleu_num{suffix}": self.numerator.detach().float(),
+                f"{prefix}bleu_denom{suffix}": self.denominator.detach().float(),
+            }
+        return {
+            f"{prefix}bleu{suffix}": bleu,
+        }
+
+    # Adding wrapper to avoid imports and extra variables over the namespace
+    def _compute_bleu(
+        self,
+        predictions_lengths,
+        targets_lengths,
+        numerator,
+        denominator,
+    ):
+        return _bleu_score_compute(
+            predictions_lengths, targets_lengths, numerator, denominator, self.n_gram, self.weights, self.smooth
+        )