修复 nemo-toolkit 中的 SIGKILL 问题

convert_ja_tar.py

@@ -0,0 +1,23 @@
+import sys
+import os
+
+# 将 scripts/speech_recognition 添加到 sys.path，以便导入 convert_to_tarred_audio_dataset
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "scripts", "speech_recognition")))
+
+import convert_to_tarred_audio_dataset
+
+def main():
+    convert_to_tarred_audio_dataset.create_tar_datasets(
+        manifest_path="data/common_voice_11_0/ja/train/train_common_voice_11_0_manifest.json",
+        target_dir="data/common_voice_11_0/ja/train_tarred_1bk",
+        num_shards=1024,
+        max_duration=15.0,
+        min_duration=1.0,
+        shuffle=True,
+        shuffle_seed=1,
+        sort_in_shards=True,
+        workers=-1
+    )
+
+if __name__ == "__main__":
+    main()

how_to_use_cv11.py

@@ -1,30 +0,0 @@
-# Load the dataset (locally)
-
-from datasets import load_dataset
-
-cv_11 = load_dataset("mozilla-foundation/common_voice_11_0", "hi", split="train")
-
-# Stream the dataset
-
-from datasets import load_dataset
-
-cv_11 = load_dataset("mozilla-foundation/common_voice_11_0", "hi", split="train", streaming=True)
-
-print(next(iter(cv_11)))
-
-# Create a PyTorch dataloader
-
-from datasets import load_dataset
-from torch.utils.data.sampler import BatchSampler, RandomSampler
-
-cv_11 = load_dataset("mozilla-foundation/common_voice_11_0", "hi", split="train")
-batch_sampler = BatchSampler(RandomSampler(cv_11), batch_size=32, drop_last=False)
-dataloader = DataLoader(cv_11, batch_sampler=batch_sampler)
-
-# Create a streaming PyTorch dataloader
-
-from datasets import load_dataset
-from torch.utils.data import DataLoader
-
-cv_11 = load_dataset("mozilla-foundation/common_voice_11_0", "hi", split="train")
-dataloader = DataLoader(cv_11, batch_size=32)

main.py

@@ -0,0 +1,41 @@
+
+def clear_text():
+    """
+    好像不需要
+    """
+    import json
+    from tqdm import tqdm
+
+    # dev_manifest = f"{YOUR_DATA_ROOT}/validation/validation_mozilla-foundation_common_voice_11_0_manifest.json"
+    # test_manifest = f"{YOUR_DATA_ROOT}/test/test_mozilla-foundation_common_voice_11_0_manifest.json"
+    train_manifest = f"data/common_voice_11_0/ja/train/train_common_voice_11_0_manifest.json"
+
+    def compute_char_counts(manifest):
+        char_counts = {}
+        with open(manifest, 'r') as fn_in:
+            for line in tqdm(fn_in, desc="Compute counts.."):
+                line = line.replace("\n", "")
+                data = json.loads(line)
+                text = data["text"]
+                for word in text.split():
+                    for char in word:
+                        if char not in char_counts:
+                            char_counts[char] = 1
+                        else:
+                            char_counts[char] += 1
+        return char_counts
+
+    char_counts = compute_char_counts(train_manifest)
+
+    threshold = 10
+    trash_char_list = []
+
+    for char in char_counts:
+        if char_counts[char] <= threshold:
+            trash_char_list.append(char)
+    
+    print(trash_char_list)
+
+if __name__ == "__main__":
+    # clear_text()
+    pass

nemo/README.md

@@ -1,26 +0,0 @@
-NeMo (**Ne**ural **Mo**dules) is a toolkit for creating AI applications built around **neural modules**, conceptual blocks of neural networks that take *typed* inputs and produce *typed* outputs.
-
-## **collections/**
-* **ASR** - Collection of modules and models for building speech recognition networks.
-* **TTS** - Collection of modules and models for building speech synthesis networks.
-* **Audio** - Collection of modules and models for building audio processing networks.
-* **SpeechLM2** - Collection of modules and models for building multimodal LLM.
-
-## **core/**
-Provides fundamental APIs and utilities for NeMo modules, including:
-- **Classes** - Base classes for datasets, models, and losses.
-- **Config** - Configuration management utilities.
-- **Neural Types** - Typed inputs/outputs for module interaction.
-- **Optim** - Optimizers and learning rate schedulers.
-
-## **lightning/**
-Integration with PyTorch Lightning for training and distributed execution:
-- **Strategies & Plugins** - Custom Lightning strategies.
-- **Fabric** - Lightweight wrapper for model training.
-- **Checkpointing & Logging** - Utilities for managing model states.
-
-## **utils/**
-General utilities for debugging, distributed training, logging, and model management:
-- **callbacks/** - Hooks for training processes.
-- **loggers/** - Logging utilities for different backends.
-- **debugging & profiling** - Performance monitoring tools.

nemo/__init__.py

@@ -1,28 +0,0 @@
-# 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/agents/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/__init__.py

@@ -1,18 +0,0 @@
-# Copyright (c) 2025, 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.
-
-try:
-    import pipecat
-except ImportError:
-    raise ImportError("pipecat is not installed. Please install it with `pip install pipecat-ai`.")

nemo/agents/voice_agent/pipecat/frames/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/frames/frames.py

@@ -1,26 +0,0 @@
-# Copyright (c) 2025, 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
-import numpy as np
-from pipecat.frames.frames import DataFrame
-
-
-@dataclass
-class DiarResultFrame(DataFrame):
-    """Diarization frame."""
-
-    diar_result: np.ndarray | int
-    stream_id: str = "default"

nemo/agents/voice_agent/pipecat/processors/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/processors/frameworks/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/processors/frameworks/rtvi.py

@@ -1,72 +0,0 @@
-# Copyright (c) 2025, 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 loguru import logger
-from pipecat.frames.frames import Frame, LLMFullResponseEndFrame, LLMFullResponseStartFrame, TTSTextFrame
-from pipecat.observers.base_observer import FramePushed
-from pipecat.processors.frameworks.rtvi import (
-    RTVIBotLLMStartedMessage,
-    RTVIBotLLMStoppedMessage,
-    RTVIBotTranscriptionMessage,
-    RTVIBotTTSTextMessage,
-)
-from pipecat.processors.frameworks.rtvi import RTVIObserver as _RTVIObserver
-from pipecat.processors.frameworks.rtvi import RTVIProcessor, RTVITextMessageData
-from pipecat.transports.base_output import BaseOutputTransport
-
-
-class RTVIObserver(_RTVIObserver):
-    """
-    An observer that processes RTVI frames and pushes them to the transport.
-    """
-
-    def __init__(self, rtvi: RTVIProcessor, *args, **kwargs):
-        super().__init__(rtvi, *args, **kwargs)
-
-    async def on_push_frame(self, data: FramePushed):
-        """Process a frame being pushed through the pipeline.
-
-        Args:
-            data: Frame push event data containing source, frame, direction, and timestamp.
-        """
-        src = data.source
-        frame: Frame = data.frame
-
-        if frame.id in self._frames_seen:
-            return
-
-        if not self._params.bot_llm_enabled:
-            if isinstance(frame, LLMFullResponseStartFrame):
-                await self.send_rtvi_message(RTVIBotLLMStartedMessage())
-                self._frames_seen.add(frame.id)
-            elif isinstance(frame, LLMFullResponseEndFrame):
-                await self.send_rtvi_message(RTVIBotLLMStoppedMessage())
-                self._frames_seen.add(frame.id)
-            elif isinstance(frame, TTSTextFrame) and isinstance(src, BaseOutputTransport):
-                message = RTVIBotTTSTextMessage(data=RTVITextMessageData(text=frame.text))
-                await self.send_rtvi_message(message)
-                await self._push_bot_transcription(frame.text)
-                self._frames_seen.add(frame.id)
-            else:
-                await super().on_push_frame(data)
-        else:
-            await super().on_push_frame(data)
-
-    async def _push_bot_transcription(self, text: str):
-        """Push accumulated bot transcription as a message."""
-        if len(text.strip()) > 0:
-            message = RTVIBotTranscriptionMessage(data=RTVITextMessageData(text=text))
-            logger.debug(f"Pushing bot transcription: `{text}`")
-            await self.send_rtvi_message(message)

nemo/agents/voice_agent/pipecat/services/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/services/nemo/__init__.py

@@ -1,19 +0,0 @@
-# Copyright (c) 2025, 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 .diar import NemoDiarService
-from .llm import HuggingFaceLLMService
-from .stt import NemoSTTService
-from .tts import NeMoFastPitchHiFiGANTTSService
-from .turn_taking import NeMoTurnTakingService

nemo/agents/voice_agent/pipecat/services/nemo/audio_logger.py

@@ -1,844 +0,0 @@
-# Copyright (c) 2025, 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 threading
-import wave
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, Union
-
-import librosa
-import numpy as np
-from loguru import logger
-from pipecat.frames.frames import TranscriptionFrame
-from pipecat.observers.base_observer import BaseObserver, FramePushed
-
-
-class AudioLogger:
-    """
-    Utility class for logging audio data and transcriptions during voice agent interactions.
-
-    This logger saves:
-    - Audio files in WAV format
-    - Transcriptions with metadata in JSON format
-    - Session information and metadata
-
-    File structure:
-        log_dir/
-        ├── session_YYYYMMDD_HHMMSS/
-        │   ├── user/
-        │   │   ├── 00001_HHMMSS.wav
-        │   │   ├── 00001_HHMMSS.json
-        │   │   ├── 00002_HHMMSS.wav
-        │   │   └── 00002_HHMMSS.json
-        │   ├── agent/
-        │   │   ├── 00001_HHMMSS.wav
-        │   │   ├── 00001_HHMMSS.json
-        │   └── session_metadata.json
-
-    Args:
-        log_dir: Base directory for storing logs (default: "./audio_logs")
-        session_id: Optional custom session ID. If None, auto-generated from timestamp
-        enabled: Whether logging is enabled (default: True)
-
-    # 12/19/2025 Note: Stereo conversation recording is implemented,
-    # but -0.8 seconds offset needs to be applied to make the session sound synced.
-    """
-
-    def __init__(
-        self,
-        log_dir: Union[str, Path] = "./audio_logs",
-        session_id: Optional[str] = None,
-        enabled: bool = True,
-        user_audio_sample_rate: int = 16000,
-        pre_roll_time_sec: float = 0.8,
-        round_precision: int = 2,
-    ):
-        self.enabled = enabled
-        if not self.enabled:
-            logger.info("[AudioLogger] AudioLogger is disabled")
-            return
-
-        self.log_dir = Path(log_dir)
-
-        # Generate session ID if not provided
-        self.session_start_time = datetime.now()
-        if session_id is None:
-            session_id = f"session_{self.session_start_time.strftime('%Y%m%d_%H%M%S')}"
-        self.first_audio_timestamp = None
-        self.session_id = session_id
-        self.session_dir = self.log_dir / session_id
-
-        # Create directories
-        self.user_dir = self.session_dir / "user"
-        self.agent_dir = self.session_dir / "agent"
-
-        self.user_dir.mkdir(parents=True, exist_ok=True)
-        self.agent_dir.mkdir(parents=True, exist_ok=True)
-
-        # Counters for file naming (thread-safe)
-        self._user_counter = 0
-        self._agent_counter = 0
-        self._turn_index = 0  # Turn index for conversation turns
-        self._current_speaker = None  # Track current speaker for turn transitions
-        self._agent_turn_start_time = None  # Captured when BotStartedSpeakingFrame is received
-        self._lock = threading.Lock()
-        self.staged_metadata = None
-        self._staged_audio_data = None
-        self._pre_roll_time_sec = pre_roll_time_sec
-        self._round_precision = round_precision
-
-        self.turn_audio_buffer = []
-        self.continuous_user_audio_buffer = []
-        self.turn_transcription_buffer = []
-
-        # Stereo conversation recording (left=agent, right=user)
-        self._stereo_conversation_filename = "conversation_stereo.wav"
-        self._stereo_conversation_file = self.session_dir / self._stereo_conversation_filename
-        self._stereo_sample_rate = user_audio_sample_rate  # Use user audio sample rate (downsample agent audio)
-        self._stereo_audio_buffer_left: list = []  # Agent audio (left channel)
-        self._stereo_audio_buffer_right: list = []  # User audio (right channel)
-
-        # Session metadata
-        # agent_entries is a list of lists: each sublist contains segments for one turn
-        # e.g., [[seg1, seg2, seg3], [seg4, seg5], ...]  where each [] is a turn
-        self.session_metadata = {
-            "session_id": session_id,
-            "start_time": self.session_start_time.isoformat(),
-            "user_entries": [],
-            "agent_entries": [],  # List of turns, each turn is a list of segments
-        }
-
-        logger.info(f"[AudioLogger] AudioLogger initialized: {self.session_dir}")
-
-    def append_continuous_user_audio(self, audio_data: bytes):
-        """
-        Append audio data to the continuous user audio buffer for stereo conversation.
-
-        This method should be called for EVERY audio frame received from the user,
-        regardless of VAD state, to record the complete conversation audio.
-
-        Args:
-            audio_data: Raw audio data as bytes
-        """
-        if not self.enabled:
-            return
-
-        self.continuous_user_audio_buffer.append(audio_data)
-
-    def _resample_audio(
-        self,
-        audio_data: Union[bytes, np.ndarray],
-        orig_sr: int,
-        target_sr: int,
-    ) -> np.ndarray:
-        """
-        Resample audio data to a target sample rate using librosa.
-
-        Args:
-            audio_data: Audio data as bytes (int16) or numpy array
-            orig_sr: Original sample rate
-            target_sr: Target sample rate
-
-        Returns:
-            Resampled audio as numpy array (float32)
-        """
-        # Convert bytes to numpy array if needed
-        if isinstance(audio_data, bytes):
-            audio_array = np.frombuffer(audio_data, dtype=np.int16).astype(np.float32) / 32768.0
-        elif audio_data.dtype == np.int16:
-            audio_array = audio_data.astype(np.float32) / 32768.0
-        else:
-            audio_array = audio_data.astype(np.float32)
-
-        # Resample if needed
-        if orig_sr != target_sr:
-            audio_array = librosa.resample(audio_array, orig_sr=orig_sr, target_sr=target_sr)
-
-        return audio_array
-
-    def _append_to_stereo_conversation(
-        self,
-        audio_data: Union[bytes, np.ndarray],
-        channel: str,
-        start_time: float,
-        sample_rate: int,
-    ):
-        """
-        Append audio to the stereo conversation buffer at the correct time position.
-
-        Args:
-            audio_data: Audio data as bytes or numpy array
-            channel: "left" for agent, "right" for user
-            start_time: Start time in seconds from session start
-            sample_rate: Sample rate of the input audio
-        """
-        if not self.enabled:
-            return
-
-        try:
-            # Resample to stereo sample rate if needed
-            audio_float = self._resample_audio(audio_data, sample_rate, self._stereo_sample_rate)
-
-            # Calculate the sample position for this audio
-            start_sample = int(start_time * self._stereo_sample_rate)
-
-            # Get the appropriate buffer
-            if channel == "left":
-                buffer = self._stereo_audio_buffer_left
-            else:
-                buffer = self._stereo_audio_buffer_right
-
-            # Extend buffer with zeros if needed to reach start position
-            current_length = len(buffer)
-            if start_sample > current_length:
-                buffer.extend([0.0] * (start_sample - current_length))
-
-            # Append or overwrite audio samples
-            for i, sample in enumerate(audio_float):
-                pos = start_sample + i
-                if pos < len(buffer):
-                    # Mix with existing audio (in case of overlap)
-                    buffer[pos] = np.clip(buffer[pos] + sample, -1.0, 1.0)
-                else:
-                    buffer.append(sample)
-
-            logger.debug(
-                f"[AudioLogger] Appended {len(audio_float)} samples to {channel} channel "
-                f"at position {start_sample} (buffer now {len(buffer)} samples)"
-            )
-
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error appending to stereo conversation: {e}")
-
-    def save_stereo_conversation(self):
-        """
-        Save the stereo conversation buffer to a WAV file.
-        Left channel = Agent, Right channel = User.
-
-        User audio comes from continuous_user_audio_buffer (not affected by VAD).
-        """
-        if not self.enabled:
-            return
-
-        if not self._stereo_audio_buffer_left and not self.continuous_user_audio_buffer:
-            logger.warning("[AudioLogger] No stereo conversation audio to save")
-            return
-
-        try:
-            # Build right channel (user) from continuous buffer
-            # This is raw bytes at user sample rate, no resampling needed since stereo uses user sample rate
-            if self.continuous_user_audio_buffer:
-                continuous_audio_bytes = b"".join(self.continuous_user_audio_buffer)
-                right_array = np.frombuffer(continuous_audio_bytes, dtype=np.int16).astype(np.float32) / 32768.0
-            else:
-                right_array = np.array([], dtype=np.float32)
-
-            left_array = np.array(self._stereo_audio_buffer_left, dtype=np.float32)
-
-            # Pad the shorter buffer with zeros
-            max_length = max(len(left_array), len(right_array))
-
-            # Pad to same length
-            if len(left_array) < max_length:
-                left_array = np.pad(left_array, (0, max_length - len(left_array)))
-            if len(right_array) < max_length:
-                right_array = np.pad(right_array, (0, max_length - len(right_array)))
-
-            # Create stereo array (interleaved: L, R, L, R, ...)
-            stereo_array = np.column_stack((left_array, right_array))
-
-            # Convert to int16
-            stereo_int16 = (stereo_array * 32767).astype(np.int16)
-
-            # Save as WAV
-            with wave.open(str(self._stereo_conversation_file), 'wb') as wav_file:  # type: ignore[union-attr]
-                wav_file.setnchannels(2)  # Stereo
-                wav_file.setsampwidth(2)  # 16-bit
-                wav_file.setframerate(self._stereo_sample_rate)
-                wav_file.writeframes(stereo_int16.tobytes())
-
-            duration_sec = max_length / self._stereo_sample_rate
-            logger.info(
-                f"[AudioLogger] Saved stereo conversation: {self._stereo_conversation_file} "
-                f"({duration_sec:.2f} seconds, {max_length} samples)"
-            )
-
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error saving stereo conversation: {e}")
-
-    def get_time_from_start_of_session(self, timestamp: datetime = None) -> float:
-        """Get the time from the start of the session to the given datetime string."""
-        # get the time difference in seconds.
-        if self.first_audio_timestamp is None:
-            raise ValueError("First audio timestamp is not set. Aborting time calculation.")
-        time_diff = (timestamp if timestamp else datetime.now()) - self.first_audio_timestamp
-        return time_diff.total_seconds()
-
-    def _get_next_counter(self, speaker: str) -> int:
-        """Get the next counter value for a speaker in a thread-safe manner."""
-        with self._lock:
-            if speaker == "user":
-                self._user_counter += 1
-                return self._user_counter
-            else:
-                self._agent_counter += 1
-                return self._agent_counter
-
-    def increment_turn_index(self, speaker: str = None) -> int:
-        """
-        Increment the turn index if the speaker has changed.
-
-        Args:
-            speaker: "user" or "agent". If provided, only increments
-                    if this is different from the current speaker.
-                    If None, always increments.
-
-        Returns:
-            The current turn index after any increment.
-        """
-        with self._lock:
-            if speaker is None:
-                # Always increment if no speaker specified
-                self._turn_index += 1
-                logger.debug(f"[AudioLogger] Turn index incremented to {self._turn_index}")
-            elif speaker != self._current_speaker:
-                # Only increment if speaker changed
-                self._current_speaker = speaker
-                self._turn_index += 1
-                # Reset agent turn start time when speaker changes
-                if speaker == "agent":
-                    self._agent_turn_start_time = None
-                logger.debug(
-                    f"[AudioLogger] Speaker changed to {speaker}, turn index incremented to {self._turn_index}"
-                )
-            # else: same speaker, no increment
-            return self._turn_index
-
-    def set_agent_turn_start_time(self):
-        """
-        Set the start time for the current agent turn.
-
-        This should be called when BotStartedSpeakingFrame is received,
-        which indicates the audio is actually starting to play (not just generated).
-        This provides more accurate timing than capturing time during TTS generation.
-        """
-        if not self.enabled:
-            return
-
-        # Only set if not already set for this turn
-        if self._agent_turn_start_time is None:
-            self._agent_turn_start_time = self.get_time_from_start_of_session()
-            logger.debug(f"[AudioLogger] Agent turn start time set to {self._agent_turn_start_time:.3f}s")
-
-    def _save_audio_wav(
-        self,
-        audio_data: Union[bytes, np.ndarray],
-        file_path: Path,
-        sample_rate: int,
-        num_channels: int = 1,
-    ):
-        """
-        Save audio data to a WAV file.
-
-        Args:
-            audio_data: Audio data as bytes or numpy array
-            file_path: Path to save the WAV file
-            sample_rate: Audio sample rate in Hz
-            num_channels: Number of audio channels (default: 1)
-        """
-        try:
-            # Convert audio data to bytes if it's a numpy array
-            if isinstance(audio_data, np.ndarray):
-                if audio_data.dtype in [np.float32, np.float64]:
-                    # Convert float [-1, 1] to int16 [-32768, 32767]
-                    audio_data = np.clip(audio_data, -1.0, 1.0)
-                    audio_data = (audio_data * 32767).astype(np.int16)
-                elif audio_data.dtype != np.int16:
-                    audio_data = audio_data.astype(np.int16)
-                audio_bytes = audio_data.tobytes()
-            else:
-                audio_bytes = audio_data
-
-            # Write WAV file
-            with wave.open(str(file_path), 'wb') as wav_file:  # type: ignore[union-attr]
-                wav_file.setnchannels(num_channels)
-                wav_file.setsampwidth(2)  # 16-bit audio
-                wav_file.setframerate(sample_rate)
-                wav_file.writeframes(audio_bytes)
-
-            logger.debug(f"[AudioLogger] Saved audio to {file_path}")
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error saving audio to {file_path}: {e}")
-            raise
-
-    def _save_metadata_json(self, metadata: dict, file_path: Path):
-        """Save metadata to a JSON file."""
-        try:
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(metadata, f, indent=2, ensure_ascii=False)
-            logger.debug(f"[AudioLogger] Saved metadata to {file_path}")
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error saving metadata to {file_path}: {e}")
-            raise
-
-    def clear_user_audio_buffer(self):
-        """
-        Clear the user audio buffer if the user stopped speaking detected by VAD.
-        """
-        # Clear turn buffers if logging wasn't completed (e.g., no final transcription)
-        if len(self.turn_audio_buffer) > 0 or len(self.turn_transcription_buffer) > 0:
-            logger.debug(
-                "[AudioLogger] Clearing turn audio and transcription buffers due to VAD user stopped speaking"
-            )
-            self.turn_audio_buffer = []
-            self.turn_transcription_buffer = []
-
-    def stage_user_audio(
-        self,
-        timestamp_now: datetime,
-        transcription: str,
-        sample_rate: int = 16000,
-        num_channels: int = 1,
-        is_first_frame: bool = False,
-        is_backchannel: bool = False,
-        additional_metadata: Optional[dict] = None,
-    ) -> Optional[dict]:
-        """
-        Stage user audio metadata and transcription (from STT).
-        This data will be saved when the turn is complete by `save_user_audio` method.
-        Audio data is retrieved from continuous_user_audio_buffer based on timestamps.
-
-        Args:
-            timestamp_now: Timestamp when the audio was received
-            transcription: Transcribed text
-            sample_rate: Audio sample rate in Hz (default: 16000)
-            num_channels: Number of audio channels (default: 1)
-            is_first_frame: Whether this is the first frame of a turn (default: False)
-            is_backchannel: Whether this is a backchannel utterance (default: False)
-            additional_metadata: Additional metadata to include
-
-        Returns:
-            Dictionary with logged file paths, or None if logging is disabled
-        """
-        if not self.enabled:
-            return None
-
-        try:
-            # Get counter and generate filenames
-            counter = self._get_next_counter("user")
-            # timestamp_now = datetime.now()
-            base_name = f"{counter:05d}_{timestamp_now.strftime('%H%M%S')}"
-
-            audio_file = self.user_dir / f"{base_name}.wav"
-            metadata_file = self.user_dir / f"{base_name}.json"
-
-            if is_first_frame or self.staged_metadata is None or "start_time" not in self.staged_metadata:
-                raw_start_time = self.get_time_from_start_of_session(timestamp=timestamp_now)
-                # Apply pre-roll: go back pre_roll_time_sec, but don't go before the last entry's end time
-                pre_roll_start = raw_start_time - self._pre_roll_time_sec
-                if self.session_metadata["user_entries"]:
-                    last_entry_end_time = self.session_metadata["user_entries"][-1]["end_time"]
-                    _start_time = max(pre_roll_start, last_entry_end_time)
-                else:
-                    # No previous entries, just ensure we don't go negative
-                    _start_time = max(pre_roll_start, 0.0)
-            else:
-                # start_time is stored as float (seconds from session start), not ISO string
-                _start_time = self.staged_metadata["start_time"]
-
-            # Make end time into float (seconds from session start)
-            _end_time = self.get_time_from_start_of_session(timestamp=datetime.now())
-            audio_duration_sec = round(_end_time - _start_time, self._round_precision)
-
-            # Prepare metadata (initialize if None to allow update)
-            if self.staged_metadata is None:
-                self.staged_metadata = {}
-            self.staged_metadata.update(
-                {
-                    "base_name": base_name,
-                    "counter": counter,
-                    "turn_index": self._turn_index,
-                    "speaker": "user",
-                    "timestamp": timestamp_now.isoformat(),
-                    "start_time": _start_time,
-                    "end_time": _end_time,
-                    "transcription": transcription,
-                    "audio_file": audio_file.name,
-                    "sample_rate": sample_rate,
-                    "num_channels": num_channels,
-                    "audio_duration_sec": audio_duration_sec,
-                    "is_backchannel": is_backchannel,
-                }
-            )
-
-            if additional_metadata:
-                self.staged_metadata.update(additional_metadata)
-
-            return {
-                "audio_file": str(audio_file),
-                "metadata_file": str(metadata_file),
-                "counter": counter,
-            }
-
-        except Exception as e:
-            logger.error(f"Error logging user audio: {e}")
-            return None
-
-    def stage_turn_audio_and_transcription(
-        self,
-        timestamp_now: datetime,
-        is_first_frame: bool = False,
-        additional_metadata: Optional[dict] = None,
-    ):
-        """
-        Stage the complete turn audio and accumulated transcriptions.
-
-        This method is called when a final transcription is received.
-        It joins all accumulated audio and transcription chunks and stages them together.
-
-        Args:
-            timestamp_now: Timestamp when the audio was received
-            is_first_frame: Whether this is the first frame of a turn (default: False)
-            additional_metadata: Additional metadata to include (e.g., model, backend info)
-        """
-        if not self.turn_audio_buffer or not self.turn_transcription_buffer:
-            logger.debug("[AudioLogger] No audio or transcription to stage")
-            return
-
-        try:
-            complete_transcription = "".join(self.turn_transcription_buffer)
-
-            logger.debug(
-                f"[AudioLogger] Staging a turn with: {len(self.turn_audio_buffer)} audio chunks, "
-                f"{len(self.turn_transcription_buffer)} transcription chunks"
-            )
-
-            metadata = {
-                "num_transcription_chunks": len(self.turn_transcription_buffer),
-                "num_audio_chunks": len(self.turn_audio_buffer),
-            }
-            if additional_metadata:
-                metadata.update(additional_metadata)
-
-            self.stage_user_audio(
-                timestamp_now=timestamp_now,
-                transcription=complete_transcription,
-                sample_rate=self._stereo_sample_rate,
-                num_channels=1,
-                is_first_frame=is_first_frame,
-                additional_metadata=metadata,
-            )
-
-            logger.info(
-                f"[AudioLogger] Staged the audio and transcription for turn: '{complete_transcription[:50]}...'"
-            )
-
-        except Exception as e:
-            logger.warning(f"[AudioLogger] Failed to stage user audio: {e}")
-
-    def save_user_audio(self, is_backchannel: bool = False, float_divisor: float = 32768.0):
-        """Save the user audio to the disk.
-
-        Args:
-            is_backchannel: Whether this audio is a backchannel utterance (default: False)
-        """
-        # Safety check: ensure staged metadata exists and has required fields
-        if self.staged_metadata is None or "base_name" not in self.staged_metadata:
-            # This is expected - multiple TranscriptionFrames may be pushed but only one has audio staged
-            logger.debug("[AudioLogger] No staged metadata to save (this is normal for multiple frame pushes)")
-            return
-
-        try:
-            # Add backchannel metadata (only set if not already True to preserve turn-taking detection)
-            if is_backchannel or not self.staged_metadata.get("is_backchannel", False):
-                self.staged_metadata["is_backchannel"] = is_backchannel
-
-            audio_file = self.user_dir / f"{self.staged_metadata['base_name']}.wav"
-            metadata_file = self.user_dir / f"{self.staged_metadata['base_name']}.json"
-
-            # Get the audio data from continuous user audio buffer
-            stt, end = self.staged_metadata["start_time"], self.staged_metadata["end_time"]
-            continuous_audio_bytes = b"".join(self.continuous_user_audio_buffer)
-            full_audio_array = np.frombuffer(continuous_audio_bytes, dtype=np.int16).astype(np.float32) / float_divisor
-            start_idx = int(stt * self._stereo_sample_rate)
-            end_idx = int(end * self._stereo_sample_rate)
-            staged_audio_data = full_audio_array[start_idx:end_idx]
-
-            self._save_audio_wav(
-                audio_data=staged_audio_data,
-                file_path=audio_file,
-                sample_rate=self.staged_metadata["sample_rate"],
-            )
-
-            self._save_metadata_json(metadata=self.staged_metadata, file_path=metadata_file)
-            backchannel_label = " [BACKCHANNEL]" if is_backchannel else ""
-            transcription_preview = self.staged_metadata['transcription'][:50]
-            ellipsis = '...' if len(self.staged_metadata['transcription']) > 50 else ''
-            logger.info(
-                f"[AudioLogger] Saved user audio #{self.staged_metadata['counter']}"
-                f"{backchannel_label}: '{transcription_preview}{ellipsis}'"
-            )
-
-            # Note: User audio for stereo conversation is handled via continuous_user_audio_buffer
-            # which is populated in append_continuous_user_audio() (not affected by VAD)
-
-            # Update session metadata
-            with self._lock:
-                self.session_metadata["user_entries"].append(self.staged_metadata)
-                self._save_session_metadata()
-
-            self.clear_user_audio_buffer()
-
-            # Clear staged data after successful save
-            self.staged_metadata = None
-            self._staged_audio_data = None
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error saving user audio: {e}")
-            raise
-
-    def log_agent_audio(
-        self,
-        audio_data: Union[bytes, np.ndarray],
-        text: str,
-        sample_rate: int = 22050,
-        num_channels: int = 1,
-        additional_metadata: Optional[dict] = None,
-        tts_generation_time: Optional[float] = None,
-    ) -> Optional[dict]:
-        """
-        Log agent audio and text (from TTS).
-
-        Args:
-            audio_data: Generated audio data as bytes or numpy array
-            text: Input text that was synthesized
-            sample_rate: Audio sample rate in Hz (default: 22050)
-            num_channels: Number of audio channels (default: 1)
-            additional_metadata: Additional metadata to include
-            tts_generation_time: Time when TTS generation started (seconds from session start).
-                                Used to calculate actual start_time for first segment of a turn.
-
-        Returns:
-            Dictionary with logged file paths, or None if logging is disabled
-        """
-        if not self.enabled:
-            return None
-
-        try:
-            # Get counter and generate filenames
-            counter = self._get_next_counter("agent")
-            timestamp_now = datetime.now()
-            base_name = f"{counter:05d}_{timestamp_now.strftime('%H%M%S')}"
-
-            audio_file = self.agent_dir / f"{base_name}.wav"
-            metadata_file = self.agent_dir / f"{base_name}.json"
-
-            # Save audio
-            self._save_audio_wav(audio_data, audio_file, sample_rate, num_channels)
-
-            # Calculate audio duration
-            audio_duration_sec = (
-                len(audio_data) / (sample_rate * num_channels * 2)
-                if isinstance(audio_data, bytes)
-                else len(audio_data) / sample_rate
-            )
-
-            # Determine start_time based on previous segment in the same turn
-            # If this is the first segment of the turn, use tts_generation_time
-            # Otherwise, use the previous segment's end_time for sequential playback
-            start_time = None
-            with self._lock:
-                agent_entries = self.session_metadata["agent_entries"]
-                # agent_entries is a list of turns, each turn is a list of segments
-                if agent_entries and agent_entries[-1]:  # If there's a current turn with segments
-                    last_segment = agent_entries[-1][-1]  # Last segment of last turn
-                    if last_segment["turn_index"] == self._turn_index:
-                        # Same turn - start after previous segment ends
-                        start_time = last_segment["end_time"]
-
-            if start_time is None:
-                # First segment of the turn - use agent_turn_start_time (from BotStartedSpeakingFrame)
-                # This is more accurate than tts_generation_time as it reflects actual playback start
-                if self._agent_turn_start_time is not None:
-                    start_time = self._agent_turn_start_time
-                elif tts_generation_time is not None:
-                    # Fallback to tts_generation_time if agent_turn_start_time not set
-                    start_time = tts_generation_time
-                else:
-                    start_time = self.get_time_from_start_of_session(timestamp=timestamp_now)
-
-            end_time = start_time + audio_duration_sec
-
-            # Prepare metadata
-            # cutoff_time is None by default (no interruption)
-            # It will be set by set_agent_cutoff_time() if TTS is interrupted
-            metadata = {
-                "base_name": base_name,
-                "counter": counter,
-                "turn_index": self._turn_index,
-                "speaker": "agent",
-                "timestamp": timestamp_now.isoformat(),
-                "start_time": round(start_time, self._round_precision),
-                "end_time": round(end_time, self._round_precision),
-                "cutoff_time": None,  # None means not interrupted; float if interrupted
-                "text": text,
-                "audio_file": audio_file.name,
-                "sample_rate": sample_rate,
-                "num_channels": num_channels,
-                "audio_duration_sec": round(audio_duration_sec, self._round_precision),
-            }
-
-            if additional_metadata:
-                metadata.update(additional_metadata)
-
-            # Save metadata
-            self._save_metadata_json(metadata, metadata_file)
-
-            # Append to stereo conversation (left channel = agent)
-            self._append_to_stereo_conversation(
-                audio_data=audio_data,
-                channel="left",
-                start_time=start_time,
-                sample_rate=sample_rate,
-            )
-
-            # Update session metadata
-            # agent_entries is a list of turns, each turn is a list of segments
-            with self._lock:
-                agent_entries = self.session_metadata["agent_entries"]
-                # Check if we need to start a new turn or append to existing turn
-                if not agent_entries or agent_entries[-1][-1]["turn_index"] != self._turn_index:
-                    # Start a new turn (new sublist)
-                    agent_entries.append([metadata])
-                else:
-                    # Append to current turn
-                    agent_entries[-1].append(metadata)
-                self._save_session_metadata()
-
-            logger.info(f"[AudioLogger] Logged agent audio #{counter}: '{text[:50]}{'...' if len(text) > 50 else ''}'")
-
-            return {
-                "audio_file": str(audio_file),
-                "metadata_file": str(metadata_file),
-                "counter": counter,
-            }
-
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error logging agent audio: {e}")
-            return None
-
-    def set_agent_cutoff_time(self, cutoff_time: Optional[float] = None):
-        """
-        Set the cutoff time for the most recent agent audio entry.
-
-        This method should be called when TTS is interrupted by user speech.
-        The cutoff_time represents when the agent audio was actually cut off,
-        which may be earlier than the natural end_time.
-
-        Args:
-            cutoff_time: The cutoff time in seconds from session start.
-                        If None, uses current time from session start.
-        """
-        if not self.enabled:
-            return
-
-        if cutoff_time is None:
-            cutoff_time = self.get_time_from_start_of_session()
-
-        with self._lock:
-            agent_entries = self.session_metadata["agent_entries"]
-            if not agent_entries or not agent_entries[-1]:
-                logger.warning("[AudioLogger] No agent entries to set cutoff time")
-                return
-
-            # Get the current turn (last sublist) and update ALL segments in it
-            current_turn = agent_entries[-1]
-            turn_index = current_turn[0]["turn_index"]
-
-            # Update cutoff_time for ALL segments in the current turn
-            for segment in current_turn:
-                segment["cutoff_time"] = cutoff_time
-                # Also update individual JSON files
-                try:
-                    metadata_file = self.agent_dir / f"{segment['base_name']}.json"
-                    self._save_metadata_json(segment, metadata_file)
-                except Exception as e:
-                    logger.error(f"[AudioLogger] Error updating agent cutoff time for segment: {e}")
-
-            # Truncate the stereo buffer (left channel = agent) at the cutoff point
-            cutoff_sample = int(cutoff_time * self._stereo_sample_rate)
-            if cutoff_sample < len(self._stereo_audio_buffer_left):
-                # Zero out agent audio after cutoff point
-                for i in range(cutoff_sample, len(self._stereo_audio_buffer_left)):
-                    self._stereo_audio_buffer_left[i] = 0.0
-                logger.debug(
-                    f"[AudioLogger] Truncated agent stereo buffer at sample {cutoff_sample} "
-                    f"(cutoff_time={cutoff_time:.3f}s)"
-                )
-
-            logger.info(
-                f"[AudioLogger] Set cutoff_time={cutoff_time:.3f}s for turn {turn_index} "
-                f"({len(current_turn)} segments)"
-            )
-
-            # Save updated session metadata
-            self._save_session_metadata()
-
-    def _save_session_metadata(self):
-        """Save the session metadata to disk."""
-        if not self.enabled:
-            return
-
-        try:
-            metadata_file = self.session_dir / "session_metadata.json"
-            self.session_metadata["last_updated"] = datetime.now().isoformat()
-            self._save_metadata_json(self.session_metadata, metadata_file)
-        except Exception as e:
-            logger.error(f"[AudioLogger] Error saving session metadata: {e}")
-
-    def finalize_session(self):
-        """Finalize the session and save final metadata."""
-        if not self.enabled:
-            return
-
-        # Save stereo conversation before finalizing
-        self.save_stereo_conversation()
-
-        self.session_metadata["end_time"] = datetime.now().isoformat()
-        self.session_metadata["total_user_entries"] = self._user_counter
-        self.session_metadata["total_agent_segments"] = self._agent_counter
-        self.session_metadata["total_agent_turns"] = len(self.session_metadata["agent_entries"])
-        self._save_session_metadata()
-        logger.info(
-            f"[AudioLogger] Session finalized: {self.session_id} "
-            f"(User: {self._user_counter}, Agent: {self._agent_counter} segments in "
-            f"{len(self.session_metadata['agent_entries'])} turns)"
-        )
-
-
-class RTVIAudioLoggerObserver(BaseObserver):
-    """Observer that triggers audio logging when TranscriptionFrame is pushed."""
-
-    def __init__(self, audio_logger: AudioLogger):
-        super().__init__()
-        self._audio_logger = audio_logger
-
-    async def on_push_frame(self, data: FramePushed):
-        """Handle frame push events and save user audio on TranscriptionFrame."""
-        frame = data.frame
-        if isinstance(frame, TranscriptionFrame) and self._audio_logger:
-            self._audio_logger.save_user_audio()
-        # Call parent class's on_push_frame method
-        await super().on_push_frame(data)

nemo/agents/voice_agent/pipecat/services/nemo/diar.py

@@ -1,360 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-from typing import AsyncGenerator, Optional
-
-import numpy as np
-from loguru import logger
-from pipecat.frames.frames import (
-    CancelFrame,
-    EndFrame,
-    ErrorFrame,
-    Frame,
-    StartFrame,
-    VADUserStartedSpeakingFrame,
-    VADUserStoppedSpeakingFrame,
-)
-from pipecat.processors.frame_processor import FrameDirection
-from pipecat.services.stt_service import STTService
-from pipecat.transcriptions.language import Language
-from pipecat.utils.time import time_now_iso8601
-from pipecat.utils.tracing.service_decorators import traced_stt
-from pydantic import BaseModel
-
-from nemo.agents.voice_agent.pipecat.frames.frames import DiarResultFrame
-from nemo.agents.voice_agent.pipecat.services.nemo.streaming_diar import DiarizationConfig, NeMoStreamingDiarService
-
-
-class NeMoDiarInputParams(BaseModel):
-    threshold: Optional[float] = (
-        0.4  # threshold value used to determine if a speaker exists or not, setting it to a lower value will increase the sensitivity of the diarization model
-    )
-    language: Optional[Language] = Language.EN_US
-    frame_len_in_secs: Optional[float] = 0.08  # 80ms for FastConformer model
-    config_path: Optional[str] = None  # path to the Niva ASR config file
-    raw_audio_frame_len_in_secs: Optional[float] = 0.016  # 16ms for websocket transport
-    buffer_size: Optional[int] = (
-        30  # number of audio frames to buffer, 1 frame is 16ms, streaming Sortformer was trained with 6*0.08=0.48s chunks
-    )
-
-
-class NemoDiarService(STTService):
-    def __init__(
-        self,
-        *,
-        model: Optional[str] = "",
-        device: Optional[str] = "cuda:0",
-        sample_rate: Optional[int] = 16000,
-        params: Optional[NeMoDiarInputParams] = None,
-        use_vad: bool = True,
-        audio_passthrough: bool = True,
-        backend: Optional[str] = "legacy",
-        enabled: bool = True,
-        **kwargs,
-    ):
-        super().__init__(audio_passthrough=audio_passthrough, **kwargs)
-
-        self._enabled = enabled
-        self._queue = asyncio.Queue()
-        self._response_queue = asyncio.Queue()  # Add response queue
-        self._processing_task = None  # Add processing task
-        self._response_task = None  # Add response task
-        self._device = device
-        self._sample_rate = sample_rate
-        self._audio_passthrough = audio_passthrough
-        params.buffer_size = params.frame_len_in_secs // params.raw_audio_frame_len_in_secs
-        self._params = params
-        self._model_name = model
-        self._use_vad = use_vad
-        self._backend = backend
-        if not params:
-            raise ValueError("params is required")
-
-        self._load_model()
-
-        self._vad_user_speaking = False
-        self._audio_buffer = []
-        self._current_speaker_id = None
-        self._processing_running = False
-
-        if not self._use_vad:
-            self._vad_user_speaking = True
-
-    def _load_model(self):
-        if not self._enabled or not self._model_name:
-            self._model = None
-            self._enabled = False
-            return
-
-        if self._backend == "legacy":
-            cfg = DiarizationConfig()
-            cfg.device = self._device
-            self._model = NeMoStreamingDiarService(
-                cfg, self._model_name, frame_len_in_secs=self._params.frame_len_in_secs, sample_rate=self.sample_rate
-            )
-        else:
-            raise ValueError(f"Invalid backend: {self._backend}")
-        logger.info(f"Diarization service initialized on device: {self._device}")
-
-    def can_generate_metrics(self) -> bool:
-        """Indicates whether this service can generate metrics.
-
-        Returns:
-            bool: True, as this service supports metric generation.
-        """
-        return True
-
-    async def start(self, frame: StartFrame):
-        """Handle service start."""
-        await super().start(frame)
-
-        # Initialize the model if not already done
-        if not hasattr(self, "_model"):
-            self._load_model()
-
-        # Start background processing task
-        if not self._processing_task:
-            self._processing_task = self.create_task(self._processing_task_handler())
-
-        # Start response handling task
-        if not self._response_task:
-            self._response_task = self.create_task(self._response_task_handler())
-
-    async def stop(self, frame: EndFrame):
-        """Handle service stop."""
-        await super().stop(frame)
-        await self._stop_tasks()
-
-    async def cancel(self, frame: CancelFrame):
-        """Handle service cancellation."""
-        await super().cancel(frame)
-        await self._stop_tasks()
-
-    async def _stop_tasks(self):
-        """Stop background processing tasks."""
-        await self._queue.put(None)  # Signal to stop processing
-        if self._processing_task:
-            await self.cancel_task(self._processing_task)
-            self._processing_task = None
-
-        if self._response_task:
-            await self.cancel_task(self._response_task)
-            self._response_task = None
-
-    def _diarization_processor(self):
-        """Background processor that handles diarization calls."""
-        try:
-            while self._processing_running:
-                try:
-                    # Get audio from queue - blocking call that will be interrupted by cancellation
-                    future = asyncio.run_coroutine_threadsafe(self._queue.get(), self.get_event_loop())
-                    audio = future.result()
-
-                    if audio is None:  # Stop signal
-                        logger.debug("Received stop signal in background processor")
-                        break
-
-                    # Process diarization
-                    diar_result = self._model.diarize(audio)
-
-                    # Send result back to async loop
-                    asyncio.run_coroutine_threadsafe(self._response_queue.put(diar_result), self.get_event_loop())
-
-                except Exception as e:
-                    logger.error(f"Error in background diarization processor: {e}")
-                    # Send error back to async loop
-                    asyncio.run_coroutine_threadsafe(self._response_queue.put(('error', e)), self.get_event_loop())
-
-        except Exception as e:
-            logger.error(f"Background diarization processor fatal error: {e}")
-        finally:
-            logger.debug("Background diarization processor stopped")
-
-    async def _processing_task_handler(self):
-        """Handler for background processing task."""
-        try:
-            self._processing_running = True
-            logger.debug("Starting background processing task")
-            await asyncio.to_thread(self._diarization_processor)
-        except asyncio.CancelledError:
-            logger.debug("Background processing task cancelled")
-            self._processing_running = False
-            raise
-        finally:
-            self._processing_running = False
-
-    async def _handle_diarization_result(self, diar_result):
-        """Handle diarization result from background processing."""
-        try:
-            if diar_result is None:
-                return
-            dominant_speaker_id = self._get_dominant_speaker_id(diar_result)
-            # logger.debug(f"Dominant speaker ID: {dominant_speaker_id}")
-            if dominant_speaker_id is not None and dominant_speaker_id != self._current_speaker_id:
-                self._current_speaker_id = dominant_speaker_id
-                logger.debug(f"Pushing DiarResultFrame with speaker {dominant_speaker_id}")
-                await self.push_frame(DiarResultFrame(dominant_speaker_id, stream_id="default"))
-        except Exception as e:
-            logger.error(f"Error handling diarization result: {e}")
-            await self.push_frame(
-                ErrorFrame(
-                    str(e),
-                    time_now_iso8601(),
-                )
-            )
-
-    async def _response_task_handler(self):
-        """Handler for processing diarization results."""
-        logger.debug("Response task handler started")
-        try:
-            while True:
-                try:
-                    result = await self._response_queue.get()
-
-                    if isinstance(result, tuple) and result[0] == 'error':
-                        # Handle error from background processing
-                        error = result[1]
-                        logger.error(f"Error in NeMo Diarization processing: {error}")
-                        await self.push_frame(
-                            ErrorFrame(
-                                str(error),
-                                time_now_iso8601(),
-                            )
-                        )
-                    else:
-                        # Handle successful diarization result
-                        await self._handle_diarization_result(result)
-
-                except Exception as e:
-                    logger.error(f"Error in response task handler: {e}")
-        except asyncio.CancelledError:
-            logger.debug("Response task handler cancelled")
-            raise
-
-    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
-        """Process audio data and generate transcription frames.
-
-        Args:
-            audio: Raw audio bytes to transcribe
-
-        Yields:
-            Frame: Transcription frames containing the results
-        """
-        if self._vad_user_speaking and self._enabled:
-            self._audio_buffer.append(audio)
-            if len(self._audio_buffer) >= self._params.buffer_size:
-                await self.start_ttfb_metrics()
-                await self.start_processing_metrics()
-                audio = b"".join(self._audio_buffer)
-                self._audio_buffer = []
-                # Queue audio for background processing
-                await self._queue.put(audio)
-        yield None
-
-    @traced_stt
-    async def _handle_transcription(self, transcript: str, is_final: bool, language: Optional[str] = None):
-        """Handle a transcription result.
-
-        Args:
-            transcript: The transcribed text
-            is_final: Whether this is a final transcription
-            language: The language of the transcription
-        """
-        pass  # Base implementation - can be extended for specific handling needs
-
-    async def set_language(self, language: Language):
-        """Update the service's recognition language.
-
-        Args:
-            language: New language for recognition
-        """
-        if self._params:
-            self._params.language = language
-        else:
-            self._params = NeMoDiarInputParams(language=language)
-
-        logger.info(f"Switching STT language to: {language}")
-
-    async def set_model(self, model: str):
-        """Update the service's model.
-
-        Args:
-            model: New model name/path to use
-        """
-        await super().set_model(model)
-        self._model_name = model
-        self._load_model()
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        """Process audio data and generate transcription frames.
-
-        Args:
-            audio: Raw audio bytes to transcribe
-
-        Yields:
-            Frame: Transcription frames containing the results
-        """
-        if not self._enabled:
-            # if diarization is disabled, just pass the frame through
-            await self.push_frame(frame, direction)
-            return
-
-        await super().process_frame(frame, direction)
-        if isinstance(frame, VADUserStartedSpeakingFrame):
-            self._vad_user_speaking = True
-            self._audio_buffer = []
-            logger.debug("VADUserStartedSpeakingFrame received")
-        elif isinstance(frame, VADUserStoppedSpeakingFrame):
-            self._vad_user_speaking = False
-            logger.debug("VADUserStoppedSpeakingFrame received")
-            self._current_speaker_id = None
-            self._audio_buffer = []
-
-    def reset(self):
-        """Reset the diarization service."""
-        self._current_speaker_id = None
-        self._audio_buffer = []
-        self._vad_user_speaking = False
-        self._model.reset_state()
-
-    def _get_dominant_speaker_id(self, spk_pred: np.ndarray):
-        spk_pred = (spk_pred > self._params.threshold).astype(int)
-        dominant_speaker_id = None
-        if spk_pred.sum() > 0:
-            # get the dominant speaker id
-            # Filter to only keep frames that have any speaker probability > 0.0
-            valid_frame_mask = spk_pred.sum(axis=1) > 0
-
-            # Filter diar_result to only keep valid frames
-            filtered_diar_result = spk_pred[valid_frame_mask]  # ndarray of shape [num_valid_frames, num_speakers]
-
-            # Get the primary speaker for each valid frame
-            primary_spk = np.argmax(filtered_diar_result, axis=1)  # ndarray of shape [num_valid_frames]
-            # logger.debug(f"Primary speaker for valid frames: {primary_spk}")
-
-            # count the number of different speakers in the primary speaker sequence
-            num_speakers = len(np.unique(primary_spk))
-            # logger.debug(f"Number of different speakers: {num_speakers}")
-
-            # If there are multiple speakers, get the dominant one
-            if num_speakers > 1:
-                # Count occurrences of each speaker
-                speaker_counts = np.bincount(primary_spk)
-                dominant_speaker_id = np.argmax(speaker_counts)
-            else:
-                # Only one speaker, return that speaker ID
-                dominant_speaker_id = primary_spk[0]
-        return dominant_speaker_id

nemo/agents/voice_agent/pipecat/services/nemo/llm.py

@@ -1,760 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-import os
-import socket
-import subprocess
-import time
-import uuid
-from threading import Thread
-from typing import AsyncGenerator, List, Mapping, Optional
-
-import psutil
-import requests
-from jinja2.exceptions import TemplateError
-from loguru import logger
-from omegaconf import DictConfig, OmegaConf
-from openai import APITimeoutError, AsyncStream, BadRequestError
-from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
-from pipecat.adapters.services.open_ai_adapter import OpenAILLMInvocationParams
-from pipecat.frames.frames import (
-    CancelFrame,
-    EndFrame,
-    LLMFullResponseEndFrame,
-    LLMFullResponseStartFrame,
-    LLMTextFrame,
-)
-from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
-from pipecat.services.openai.llm import OpenAILLMService
-from transformers import AsyncTextIteratorStreamer, AutoModelForCausalLM, AutoTokenizer
-from vllm.config import ModelConfig as vllmModelConfig
-
-DEFAULT_GENERATION_KWARGS = {
-    "max_new_tokens": 256,
-    "temperature": 0.7,
-    "top_p": 0.9,
-    "do_sample": True,
-}
-
-
-class LLMUtilsMixin:
-    """Utils for local LLM services."""
-
-    def _maybe_add_user_message(self, messages: List[ChatCompletionMessageParam]) -> List[ChatCompletionMessageParam]:
-        """
-        Some LLMs like "nvidia/Llama-3.1-Nemotron-Nano-8B-v1" requires a user turn after the system prompt,
-        this function is used to add a dummy user turn if the system prompt is followed by an assistant turn.
-        """
-        if len(messages) > 1 and messages[0]["role"] == "system" and messages[1]["role"] == "assistant":
-            message = {"role": "user", "content": "Hi"}
-            messages.insert(1, message)
-        elif len(messages) == 1 and messages[0]["role"] == "system":
-            messages.append({"role": "user", "content": "Hi"})
-        return messages
-
-    def _maybe_merge_consecutive_user_turns(
-        self, messages: List[ChatCompletionMessageParam]
-    ) -> List[ChatCompletionMessageParam]:
-        """
-        Merge consecutive user turns into a single turn,
-        since some LLMs like "nvidia/Llama-3.1-Nemotron-Nano-8B-v1" do not support consecutive user turns.
-        """
-        if not messages:
-            return messages
-
-        merged_messages = []
-
-        user_content = ""
-        for message in messages:
-            role = message["role"]
-            if role != "user":
-                # check if there's any preceeding user content, add them first
-                if user_content:
-                    merged_messages.append({"role": "user", "content": user_content})
-                    user_content = ""
-                merged_messages.append(message)
-            else:
-                if user_content:
-                    user_content += "; " + message["content"]
-                else:
-                    user_content = message["content"]
-
-        # add the last user content
-        if user_content:
-            merged_messages.append({"role": "user", "content": user_content})
-
-        return merged_messages
-
-
-class HuggingFaceLLMLocalService(LLMUtilsMixin):
-    """
-    HuggingFace LLM local service.
-    """
-
-    def __init__(
-        self,
-        model: str = "meta-llama/Meta-Llama-3-8B-Instruct",
-        device: str = "cuda:0",
-        dtype: str = "bfloat16",
-        thinking_budget: int = 0,
-        generation_kwargs: dict = None,
-        apply_chat_template_kwargs: dict = None,
-    ):
-        self.device = device
-        self.dtype = dtype
-        self.thinking_budget = thinking_budget
-        self.tokenizer = AutoTokenizer.from_pretrained(model)
-        self.model = AutoModelForCausalLM.from_pretrained(
-            model, device_map=device, dtype=dtype, trust_remote_code=True
-        )  # type: AutoModelForCausalLM
-
-        self.generation_kwargs = generation_kwargs if generation_kwargs else DEFAULT_GENERATION_KWARGS
-        logger.debug(f"LLM generation kwargs: {self.generation_kwargs}")
-
-        self.apply_chat_template_kwargs = apply_chat_template_kwargs if apply_chat_template_kwargs else {}
-        if "tokenize" in self.apply_chat_template_kwargs:
-            if self.apply_chat_template_kwargs["tokenize"] is not False:
-                logger.warning(
-                    f"Found `tokenize=True` in apply_chat_template_kwargs={self.apply_chat_template_kwargs},"
-                    "it will be ignored and forced to `False`"
-                )
-            self.apply_chat_template_kwargs.pop("tokenize")
-
-        logger.debug(f"LLM apply_chat_template kwargs: {self.apply_chat_template_kwargs}")
-
-    def _apply_chat_template(self, messages: List[ChatCompletionMessageParam]) -> str:
-        """
-        Apply the chat template to the messages.
-        """
-        return self.tokenizer.apply_chat_template(messages, tokenize=False, **self.apply_chat_template_kwargs)
-
-    def _get_prompt_from_messages(self, messages: List[ChatCompletionMessageParam]) -> str:
-        """
-        Get the formatted prompt from the conversation history messages.
-        This function also tries to fix the messages if the LLM cannot handle consecutive turns of the same role,
-        or requires a user turn after the system prompt.
-        """
-        try:
-            prompt = self._apply_chat_template(messages)
-            return prompt
-        except TemplateError as e:
-            logger.warning(f"Got TemplateError: {e}.")
-
-        logger.debug(f"Input LLM messages: {messages}")
-        if len(messages) > 1 and messages[0]["role"] == "system" and messages[1]["role"] == "assistant":
-            logger.warning("Trying to fix by adding dummy user message after system prompt...")
-            try:
-                messages = self._maybe_add_user_message(messages)
-                logger.debug(f"LLM messages after adding dummy user message: {messages}")
-                prompt = self._apply_chat_template(messages)
-                return prompt
-            except TemplateError as e:
-                logger.warning(f"Got TemplateError: {e}. Trying to fix by merging consecutive turns if possible.")
-
-        try:
-            new_messages = self._maybe_merge_consecutive_user_turns(messages)
-            logger.debug(f"LLM messages after merging consecutive user turns: {new_messages}")
-            prompt = self._apply_chat_template(new_messages)
-            # Update the messages in place if successful
-            messages.clear()
-            messages.extend(new_messages)
-            return prompt
-        except Exception as e:
-            logger.warning(f"Got Exception: {e}, messages: {messages}")
-            raise e
-
-    async def generate_stream(
-        self, messages: List[ChatCompletionMessageParam], **kwargs
-    ) -> AsyncGenerator[ChatCompletionChunk, None]:
-        """
-        Generate a stream of chat completion chunks from the messages.
-        """
-        # Convert messages to prompt format
-        prompt = self._get_prompt_from_messages(messages)
-
-        logger.debug(f"LLM prompt: {prompt}")
-
-        inputs = self.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").to(self.device)
-
-        # Generate with streaming
-        streamer = AsyncTextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
-        generation_kwargs = {
-            **inputs,
-            "streamer": streamer,
-            **self.generation_kwargs,
-        }
-
-        # Start generation in background
-        thread = Thread(
-            target=self.model.generate,
-            kwargs=generation_kwargs,
-        )
-        thread.start()
-
-        # Stream the output
-        async for text in streamer:
-            # logger.debug(f"Streamer yielded text: {text}")
-            chunk = ChatCompletionChunk(
-                id="hf-" + str(uuid.uuid4()),
-                choices=[{"delta": {"content": text}, "finish_reason": None, "index": 0}],
-                created=int(time.time()),
-                model=self.model.config._name_or_path,
-                object="chat.completion.chunk",
-            )
-            yield chunk
-
-
-class HuggingFaceLLMService(OpenAILLMService):
-    """
-    LLM service that hosts a HuggingFace model.
-    """
-
-    def __init__(
-        self,
-        *,
-        model: str = "google/gemma-7b-it",
-        device: str = "cuda",
-        dtype: str = "bfloat16",
-        thinking_budget: int = 0,
-        generation_kwargs: dict = None,
-        apply_chat_template_kwargs: dict = None,
-        **kwargs,
-    ):
-        self._model_name = model
-        self._device = device
-        self._dtype = dtype
-        self._thinking_budget = thinking_budget
-        self._generation_kwargs = generation_kwargs if generation_kwargs is not None else DEFAULT_GENERATION_KWARGS
-        self._apply_chat_template_kwargs = apply_chat_template_kwargs if apply_chat_template_kwargs is not None else {}
-        super().__init__(model=model, **kwargs)
-
-    def create_client(self, api_key=None, base_url=None, **kwargs):
-        """
-        Create a HuggingFaceLLMLocalService client.
-        """
-        return HuggingFaceLLMLocalService(
-            model=self._model_name,
-            device=self._device,
-            dtype=self._dtype,
-            thinking_budget=self._thinking_budget,
-            generation_kwargs=self._generation_kwargs,
-            apply_chat_template_kwargs=self._apply_chat_template_kwargs,
-        )
-
-    async def _process_context(self, context: OpenAILLMContext):
-        """Process a context through the LLM and push text frames.
-
-        Args:
-            context (OpenAILLMContext): The context to process, containing messages
-                and other information needed for the LLM interaction.
-        """
-        await self.push_frame(LLMFullResponseStartFrame())
-        cumulative_text = ""
-        try:
-            await self.start_ttfb_metrics()
-            messages = context.get_messages()
-            async for chunk in self._client.generate_stream(messages):
-                if chunk.choices[0].delta.content:
-                    await self.stop_ttfb_metrics()
-                    text = chunk.choices[0].delta.content
-                    cumulative_text += text
-                    frame = LLMTextFrame(text)
-                    await self.push_frame(frame)
-        except Exception as e:
-            logger.error(f"Error in _process_context: {e}", exc_info=True)
-            raise
-        finally:
-            cumulative_text = " ".join(cumulative_text.split()).strip()
-            if not cumulative_text:
-                logger.warning(f"LLM response is empty for context: {context}")
-            await self.push_frame(LLMFullResponseEndFrame())
-
-    async def get_chat_completions(
-        self, params_from_context: OpenAILLMInvocationParams
-    ) -> AsyncGenerator[ChatCompletionChunk, None]:
-        """Create a streaming chat completion using HuggingFace model.
-
-        Args:
-            context (OpenAILLMContext): The context object containing tools configuration
-                and other settings for the chat completion.
-            messages (List[ChatCompletionMessageParam]): The list of messages comprising
-                the conversation history and current request.
-
-        Returns:
-            AsyncGenerator[ChatCompletionChunk]: A streaming response of chat completion
-                chunks that can be processed asynchronously.
-        """
-        messages = params_from_context["messages"]
-
-        return self._client.generate_stream(messages)
-
-
-class VLLMService(OpenAILLMService, LLMUtilsMixin):
-    """
-    LLM service that hosts a vLLM server.
-    """
-
-    def __init__(
-        self,
-        *,
-        model: str,
-        device: str = "cuda",
-        api_key="None",
-        base_url="http://localhost:8000/v1",
-        organization="None",
-        project="None",
-        default_headers: Optional[Mapping[str, str]] = None,
-        params: Optional[OpenAILLMService.InputParams] = None,
-        thinking_budget: int = 0,
-        start_vllm_on_init: bool = False,
-        vllm_server_params: Optional[str] = None,
-        vllm_server_max_wait_time: int = 3600,  # 1 hour max wait time
-        vllm_server_check_interval: int = 5,  # check server every 5 seconds
-        **kwargs,
-    ):
-        self._device = device
-        self._vllm_server_max_wait_time = vllm_server_max_wait_time
-        self._vllm_server_check_interval = vllm_server_check_interval
-        if start_vllm_on_init:
-            base_url = self._start_vllm_server(model, vllm_server_params, base_url)
-
-        super().__init__(
-            model=model,
-            api_key=api_key,
-            base_url=base_url,
-            organization=organization,
-            project=project,
-            default_headers=default_headers,
-            params=params,
-            **kwargs,
-        )
-        self._thinking_budget = thinking_budget
-        self._vllm_server_params = vllm_server_params
-        self._start_vllm_on_init = start_vllm_on_init
-
-        # TODO: handle thinking budget
-        logger.info(
-            f"VLLMService initialized with model: {model}, api_key: {api_key}, base_url: {base_url},"
-            f"params: {params}, thinking_budget: {thinking_budget}"
-        )
-
-    def _start_vllm_server(
-        self, model: str, vllm_server_params: Optional[str] = None, base_url: Optional[str] = None
-    ) -> str:
-        """
-        Start a vllm server and return the base url.
-        """
-
-        requested_port = None
-        # If base_url is provided, extract port from it
-        if base_url:
-            try:
-                # Extract port from base_url like "http://localhost:8003/v1"
-                from urllib.parse import urlparse
-
-                parsed_url = urlparse(base_url)
-                if parsed_url.port:
-                    requested_port = parsed_url.port
-            except Exception as e:
-                logger.warning(
-                    f"Could not parse port from base_url {base_url}: {e}, using port from vllm_server_params"
-                )
-
-        # Parse port from vllm_server_params, default to 8000
-        if vllm_server_params:
-            params_list = vllm_server_params.split()
-            for i, param in enumerate(params_list):
-                if param == "--port" and i + 1 < len(params_list):
-                    try:
-                        param_port = int(params_list[i + 1])
-                        if requested_port is None:
-                            requested_port = param_port
-                        else:
-                            if param_port != requested_port:
-                                logger.warning(
-                                    f"Port {param_port} from vllm_server_params is different from base_url port"
-                                    f"{requested_port}, using new port {param_port}"
-                                )
-                                requested_port = param_port
-                        break
-                    except ValueError:
-                        logger.warning(f"Invalid port number: {params_list[i + 1]}, using default 8000")
-
-        if requested_port is None:
-            # try to use default port
-            requested_port = 8000
-
-        def find_available_port(start_port: int) -> int:
-            """Find an available port starting from start_port"""
-            for port in range(start_port, start_port + 100):  # Try up to 100 ports
-                try:
-                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                        s.bind(('localhost', port))
-                        return port
-                except OSError:
-                    continue
-            raise RuntimeError(f"Could not find an available port starting from {start_port}")
-
-        def get_pid_on_port(port: int) -> Optional[int]:
-            for conn in psutil.net_connections(kind="inet"):
-                if conn.laddr.port == port and conn.status == psutil.CONN_LISTEN:
-                    return conn.pid
-            return None
-
-        def check_server_model(port: int, verbose: bool = False) -> tuple[bool, str]:
-            """Check if server is running on port and return (is_running, model_name)"""
-            try:
-                response = requests.get(f"http://localhost:{port}/v1/models", timeout=5)
-                if response.status_code == 200:
-                    # get the PID for the server process
-                    pid = get_pid_on_port(port)
-                    if pid is not None and verbose:
-                        logger.warning(
-                            f"Found vLLM server process (PID: {pid}) on port {port}, you can use `lsof -i :{port}`"
-                            "to find the process and kill it if you want to start a new server."
-                        )
-                    models_data = response.json()
-                    if "data" in models_data and models_data["data"]:
-                        served_model = models_data["data"][0].get("id", "")
-                        return True, served_model
-                    return True, ""
-                return False, ""
-            except (requests.exceptions.RequestException, requests.exceptions.Timeout):
-                return False, ""
-
-        # First, check if vLLM server is already running on the requested port
-        is_running, served_model = check_server_model(requested_port, verbose=True)
-        if is_running:
-            if served_model == model:
-                final_base_url = f"http://localhost:{requested_port}/v1"
-                logger.info(f"vLLM server is already running at {final_base_url} with the correct model: {model}")
-                return final_base_url
-            else:
-                logger.warning(
-                    f"vLLM server on port {requested_port} is serving model '{served_model}' but we need '{model}'."
-                    "Finding new port..."
-                )
-
-        # Find an available port for our model
-        port = find_available_port(requested_port)
-        if port != requested_port:
-            logger.info(f"Using port {port} instead of requested port {requested_port}")
-
-        final_base_url = f"http://localhost:{port}/v1"
-
-        # Check if there's already a vLLM process running on the same port and model
-        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-            try:
-                if proc.info['cmdline'] and any('vllm' in arg and 'serve' in arg for arg in proc.info['cmdline']):
-                    # Check if this process is using the same port and model
-                    cmdline_str = ' '.join(proc.info['cmdline'])
-                    if f"--port {port}" in cmdline_str:
-                        # Extract the model from the command line
-                        cmdline_parts = proc.info['cmdline']
-                        model_index = -1
-                        for i, arg in enumerate(cmdline_parts):
-                            if arg == "serve" and i + 1 < len(cmdline_parts):
-                                model_index = i + 1
-                                break
-
-                        if model_index != -1 and model_index < len(cmdline_parts):
-                            running_model = cmdline_parts[model_index]
-                            if running_model == model:
-                                logger.info(
-                                    f"Found existing vLLM server process (PID: {proc.info['pid']}) on port {port}"
-                                    f"serving model {model}"
-                                )
-                                # Wait a bit and check if it's responding
-                                time.sleep(2)
-                                is_running, served_model = check_server_model(port)
-                                if is_running and served_model == model:
-                                    logger.info(
-                                        f"Existing vLLM server is responding at {final_base_url} with correct model"
-                                    )
-                                    return final_base_url
-                                else:
-                                    logger.warning(
-                                        f"Existing vLLM process found on port {port} but not responding correctly,"
-                                        "will start new server"
-                                    )
-                            else:
-                                logger.info(
-                                    f"Found vLLM process on port {port} but serving different model '{running_model}'"
-                                    f"(need '{model}'). Will start new server."
-                                )
-            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                continue
-
-        # Build the command with the determined port
-        cmd_parts = ["vllm", "serve", model]
-
-        # Parse and modify vllm_server_params to use the correct port
-        if vllm_server_params:
-            # parse the vllm_server_params and add the port to the command
-            params_list = vllm_server_params.split()
-            modified_params = []
-            i = 0
-            while i < len(params_list):
-                if params_list[i] == "--port" and i + 1 < len(params_list):
-                    # Replace the port with our determined port
-                    modified_params.extend(["--port", str(port)])
-                    i += 2  # Skip the original port value
-                else:
-                    modified_params.append(params_list[i])
-                    i += 1
-            cmd_parts.extend(modified_params)
-        else:
-            # Add port if vllm_server_params is not provided
-            cmd_parts.extend(["--port", str(port)])
-
-        logger.info(f"Starting vLLM server with command: {' '.join(cmd_parts)}")
-        logger.warning("It will take a while to download the model if it's not already downloaded.")
-        # Set up environment variables for device configuration
-        env = os.environ.copy()
-        if self._device and self._device != "cpu":
-            # Extract CUDA device number if it's in format "cuda:0", "cuda:1", etc.
-            if self._device.startswith("cuda:"):
-                device_id = self._device.split(":")[1]
-                env["CUDA_VISIBLE_DEVICES"] = device_id
-                logger.info(f"Setting CUDA_VISIBLE_DEVICES={device_id}")
-            elif self._device == "cuda":
-                # Use default CUDA device (don't set CUDA_VISIBLE_DEVICES)
-                logger.info("Using default CUDA device")
-            else:
-                # For other device strings, try to extract device number
-                logger.warning(f"Unknown device format: {self._device}, using as-is")
-                env["CUDA_VISIBLE_DEVICES"] = self._device
-        elif self._device == "cpu":
-            env["CUDA_VISIBLE_DEVICES"] = ""
-            logger.info("Setting CUDA_VISIBLE_DEVICES='' to use CPU")
-
-        try:
-            # Start the vLLM server process with environment variables
-            process = subprocess.Popen(
-                cmd_parts,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                env=env,
-                preexec_fn=os.setsid if os.name != 'nt' else None,  # Create new process group
-            )
-
-            # Store the process for potential cleanup later
-            self._vllm_process = process
-
-            # Wait for server to start up
-            max_wait_time = self._vllm_server_max_wait_time
-            check_interval = self._vllm_server_check_interval
-            waited_time = 0
-
-            logger.info(f"Waiting for vLLM server to start on port {port}...")
-            while waited_time < max_wait_time:
-                is_running, served_model = check_server_model(port)
-                if is_running and served_model == model:
-                    logger.info(f"vLLM server started successfully at {final_base_url} serving model: {model}")
-                    return final_base_url
-                elif is_running and served_model != model:
-                    logger.warning(
-                        f"vLLM server started but serving wrong model '{served_model}' instead of '{model}'."
-                        "Continuing to wait..."
-                    )
-
-                # Check if process is still running
-                if process.poll() is not None:
-                    # Process has terminated
-                    stdout, stderr = process.communicate()
-                    logger.error(f"vLLM server process terminated unexpectedly. stdout: {stdout}, stderr: {stderr}")
-                    raise RuntimeError(f"Failed to start vLLM server: {stderr}")
-
-                time.sleep(check_interval)
-                waited_time += check_interval
-                logger.debug(f"Still waiting for vLLM server on port {port}... ({waited_time}s)")
-
-            # If we get here, server didn't start in time
-            logger.error(f"vLLM server failed to start within {max_wait_time} seconds on port {port}")
-            process.terminate()
-            raise RuntimeError(f"vLLM server failed to start within {max_wait_time} seconds on port {port}")
-
-        except FileNotFoundError:
-            logger.error("vLLM not found. Please install vLLM: pip install vllm")
-            raise RuntimeError("vLLM not found. Please install vLLM: pip install vllm")
-        except Exception as e:
-            logger.error(f"Failed to start vLLM server: {e}")
-            self._stop_vllm_server()
-            raise e
-
-    def _stop_vllm_server(self):
-        """Stop the vLLM server process if it's running."""
-        if hasattr(self, '_vllm_process') and self._vllm_process:
-            logger.info(f"Stopping vLLM server process {self._vllm_process.pid}")
-            self._vllm_process.terminate()
-
-    async def stop(self, frame: EndFrame):
-        """Stop the LLM service.
-
-        Args:
-            frame: The end frame.
-        """
-        await super().stop(frame)
-        self._stop_vllm_server()
-
-    async def cancel(self, frame: CancelFrame):
-        """Cancel the LLM service.
-
-        Args:
-            frame: The cancel frame.
-        """
-        await super().cancel(frame)
-        self._stop_vllm_server()
-
-    async def get_chat_completions(
-        self, params_from_context: OpenAILLMInvocationParams
-    ) -> AsyncStream[ChatCompletionChunk]:
-        """Get streaming chat completions from OpenAI API.
-
-        Args:
-            context: The LLM context containing tools and configuration.
-            messages: List of chat completion messages to send.
-
-        Returns:
-            Async stream of chat completion chunks.
-        """
-
-        params = self.build_chat_completion_params(params_from_context)
-        messages = params_from_context["messages"]
-        if self._retry_on_timeout:
-            try:
-                chunks = await asyncio.wait_for(
-                    self._get_response_from_client(messages, params), timeout=self._retry_timeout_secs
-                )
-                return chunks
-            except (APITimeoutError, asyncio.TimeoutError):
-                # Retry, this time without a timeout so we get a response
-                logger.debug(f"{self}: Retrying chat completion due to timeout")
-                chunks = await self._get_response_from_client(messages, params)
-                return chunks
-        else:
-            chunks = await self._get_response_from_client(messages, params)
-            return chunks
-
-    async def _get_response_from_client(
-        self, messages: List[ChatCompletionMessageParam], params: dict
-    ) -> AsyncStream[ChatCompletionChunk]:
-        """Get a response from the client."""
-
-        try:
-            chunks = await self._client.chat.completions.create(**params)
-        except BadRequestError as e:
-            logger.error(f"Error in _get_response_from_client: {e}, trying to fix...")
-            logger.debug(f"LLM messages before fixing: {messages}")
-            messages = self._maybe_add_user_message(messages)
-            messages = self._maybe_merge_consecutive_user_turns(messages)
-            logger.debug(f"LLM messages after fixing: {messages}")
-            params["messages"] = messages
-            chunks = await self._client.chat.completions.create(**params)
-
-        return chunks
-
-
-def get_llm_service_from_config(config: DictConfig) -> OpenAILLMService:
-    """Get an LLM service from the configuration."""
-    backend = config.type
-
-    logger.info(f"Initializing LLM service from config: {config}")
-
-    # If backend is "auto", try to detect the best backend
-    if backend == "auto":
-        model_name = config.get("model")
-        if not model_name:
-            raise ValueError("Model name is required for LLM")
-
-        try:
-            _ = vllmModelConfig(model_name, trust_remote_code=True)
-            backend = "vllm"
-            logger.info(f"Auto-detected vLLM as the best backend for model {model_name}")
-        except Exception as e:
-            logger.info(
-                f"The LLM doesn't seem to be supported by vLLM yet (error: {e}), using HuggingFace as the backend"
-                f"for model: {model_name}. If you are sure that the LLM is supported by vLLM, you can set `type: vllm`"
-                "in the config file to force using vLLM."
-            )
-            backend = "hf"
-
-    assert backend in [
-        "hf",
-        "vllm",
-        "auto",
-    ], f"Invalid backend: {backend}, only `hf`, `vllm`, and `auto` are supported."
-
-    if backend == "hf":
-        llm_model = config.model
-        llm_device = config.device
-        llm_dtype = config.dtype
-        llm_generation_kwargs = config.get("generation_kwargs", {})
-        if llm_generation_kwargs is not None:
-            llm_generation_kwargs = OmegaConf.to_container(llm_generation_kwargs, resolve=True)
-        llm_apply_chat_template_kwargs = config.get("apply_chat_template_kwargs", None)
-        if llm_apply_chat_template_kwargs is not None:
-            llm_apply_chat_template_kwargs = OmegaConf.to_container(llm_apply_chat_template_kwargs, resolve=True)
-        llm_thinking_budget = config.get("thinking_budget", 0)
-        return HuggingFaceLLMService(
-            model=llm_model,
-            device=llm_device,
-            dtype=llm_dtype,
-            generation_kwargs=llm_generation_kwargs,
-            apply_chat_template_kwargs=llm_apply_chat_template_kwargs,
-            thinking_budget=llm_thinking_budget,
-        )
-    elif backend == "vllm":
-        llm_model = config.get("model", "vllm_server")
-        llm_api_key = config.get("api_key", "None")
-        llm_base_url = config.get("base_url", "http://localhost:8000/v1")
-        llm_organization = config.get("organization", "None")
-        llm_project = config.get("project", "None")
-        llm_default_headers = config.get("default_headers", None)
-        llm_params = config.get("vllm_generation_params", None)
-        llm_dtype = config.dtype
-        vllm_server_params = config.get("vllm_server_params", None)
-        if vllm_server_params is not None:
-            if "dtype" not in vllm_server_params:
-                vllm_server_params = f"--dtype {llm_dtype} {vllm_server_params}"
-                logger.info(f"Adding dtype {llm_dtype} to vllm_server_params: {vllm_server_params}")
-        if llm_params is not None:
-            # cast into OpenAILLMService.InputParams object
-            llm_params = OmegaConf.to_container(llm_params, resolve=True)
-            extra = llm_params.get("extra", None)
-            # ensure extra is a dictionary
-            if extra is None:
-                llm_params["extra"] = {}
-            elif not isinstance(extra, dict):
-                raise ValueError(f"extra must be a dictionary, got {type(extra)}")
-            llm_params = OpenAILLMService.InputParams(**llm_params)
-        else:
-            llm_params = OpenAILLMService.InputParams()
-        llm_thinking_budget = config.get("thinking_budget", 0)
-        return VLLMService(
-            model=llm_model,
-            api_key=llm_api_key,
-            base_url=llm_base_url,
-            organization=llm_organization,
-            project=llm_project,
-            default_headers=llm_default_headers,
-            params=llm_params,
-            thinking_budget=llm_thinking_budget,
-            start_vllm_on_init=config.get("start_vllm_on_init", False),
-            vllm_server_params=vllm_server_params,
-        )
-    else:
-        raise ValueError(f"Invalid LLM backend: {backend}")

nemo/agents/voice_agent/pipecat/services/nemo/streaming_asr.py

@@ -1,319 +0,0 @@
-# Copyright (c) 2025, 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.
-# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
-
-import math
-import time
-from dataclasses import dataclass
-from typing import List, Optional
-
-import numpy as np
-import torch
-from omegaconf import open_dict
-
-import nemo.collections.asr as nemo_asr
-from nemo.agents.voice_agent.pipecat.services.nemo.utils import CacheFeatureBufferer
-from nemo.collections.asr.parts.utils.rnnt_utils import Hypothesis
-from nemo.collections.common.tokenizers.sentencepiece_tokenizer import SentencePieceTokenizer
-
-
-@dataclass
-class ASRResult:
-    text: str
-    is_final: bool
-    eou_prob: Optional[float] = None
-    eob_prob: Optional[float] = None
-    eou_latency: Optional[float] = None
-    eob_latency: Optional[float] = None
-    processing_time: Optional[float] = None
-
-
-class NemoStreamingASRService:
-    def __init__(
-        self,
-        model: str = "nvidia/parakeet_realtime_eou_120m-v1",
-        att_context_size: List[int] = [70, 1],
-        device: str = "cuda",
-        eou_string: str = "<EOU>",
-        eob_string: str = "<EOB>",
-        decoder_type: str = None,
-        chunk_size: int = -1,
-        shift_size: int = -1,
-        left_chunks: int = 2,
-        sample_rate: int = 16000,
-        frame_len_in_secs: float = 0.08,
-        use_amp: bool = False,
-        chunk_size_in_secs: float = 0.08,
-    ):
-        self.model = model
-        self.eou_string = eou_string
-        self.eob_string = eob_string
-        self.device = device
-        self.att_context_size = att_context_size
-        self.decoder_type = decoder_type
-        self.chunk_size = chunk_size
-        self.shift_size = shift_size
-        self.left_chunks = left_chunks
-        self.asr_model = self._load_model(model)
-        self.tokenizer: SentencePieceTokenizer = self.asr_model.tokenizer
-        self.use_amp = use_amp
-        self.pad_and_drop_preencoded = False
-        self.blank_id = self.get_blank_id()
-        self.chunk_size_in_secs = chunk_size_in_secs
-
-        assert len(self.att_context_size) == 2, "Att context size must be a list of two integers"
-        assert (
-            self.att_context_size[0] >= 0
-        ), f"Left att context size must be greater than 0: {self.att_context_size[0]}"
-        assert (
-            self.att_context_size[1] >= 0
-        ), f"Right att context size must be greater than 0: {self.att_context_size[1]}"
-
-        window_stride_in_secs = self.asr_model.cfg.preprocessor.window_stride
-        model_stride = self.asr_model.cfg.encoder.subsampling_factor
-        self.model_chunk_size = self.asr_model.encoder.streaming_cfg.chunk_size
-        if isinstance(self.model_chunk_size, list):
-            self.model_chunk_size = self.model_chunk_size[1]
-        self.pre_encode_cache_size = self.asr_model.encoder.streaming_cfg.pre_encode_cache_size
-        if isinstance(self.pre_encode_cache_size, list):
-            self.pre_encode_cache_size = self.pre_encode_cache_size[1]
-        self.pre_encode_cache_size_in_secs = self.pre_encode_cache_size * window_stride_in_secs
-
-        self.tokens_per_frame = math.ceil(np.trunc(self.chunk_size_in_secs / window_stride_in_secs) / model_stride)
-        # overwrite the encoder streaming params with proper shift size for cache aware streaming
-        self.asr_model.encoder.setup_streaming_params(
-            chunk_size=self.model_chunk_size // model_stride, shift_size=self.tokens_per_frame
-        )
-
-        model_chunk_size_in_secs = self.model_chunk_size * window_stride_in_secs
-
-        self.buffer_size_in_secs = self.pre_encode_cache_size_in_secs + model_chunk_size_in_secs
-
-        self._audio_buffer = CacheFeatureBufferer(
-            sample_rate=sample_rate,
-            buffer_size_in_secs=self.buffer_size_in_secs,
-            chunk_size_in_secs=self.chunk_size_in_secs,
-            preprocessor_cfg=self.asr_model.cfg.preprocessor,
-            device=self.device,
-        )
-        self._reset_cache()
-        self._previous_hypotheses = self._get_blank_hypothesis()
-        self._last_transcript_timestamp = time.time()
-        print(f"NemoStreamingASRService initialized with model `{model}` on device `{self.device}`")
-
-    def _reset_cache(self):
-        (
-            self._cache_last_channel,  # [17, B, 70, 512]
-            self._cache_last_time,  # [17, B, 512, 8]
-            self._cache_last_channel_len,  # B
-        ) = self.asr_model.encoder.get_initial_cache_state(
-            1
-        )  # batch size is 1
-
-    def _get_blank_hypothesis(self) -> List[Hypothesis]:
-        blank_hypothesis = Hypothesis(score=0.0, y_sequence=[], dec_state=None, timestamp=[], last_token=None)
-        return [blank_hypothesis]
-
-    @property
-    def drop_extra_pre_encoded(self):
-        return self.asr_model.encoder.streaming_cfg.drop_extra_pre_encoded
-
-    def get_blank_id(self):
-        return len(self.tokenizer.vocab)
-
-    def get_text_from_tokens(self, tokens: List[int]) -> str:
-        sep = "\u2581"  # '▁'
-        tokens = [int(t) for t in tokens if t != self.blank_id]
-        if tokens:
-            pieces = self.tokenizer.ids_to_tokens(tokens)
-            text = "".join([p.replace(sep, ' ') if p.startswith(sep) else p for p in pieces])
-        else:
-            text = ""
-        return text
-
-    def _load_model(self, model: str):
-        if model.endswith(".nemo"):
-            asr_model = nemo_asr.models.ASRModel.restore_from(model, map_location=torch.device(self.device))
-        else:
-            asr_model = nemo_asr.models.ASRModel.from_pretrained(model, map_location=torch.device(self.device))
-
-        if self.decoder_type is not None and hasattr(asr_model, "cur_decoder"):
-            asr_model.change_decoding_strategy(decoder_type=self.decoder_type)
-        elif isinstance(asr_model, nemo_asr.models.EncDecCTCModel):
-            self.decoder_type = "ctc"
-        elif isinstance(asr_model, nemo_asr.models.EncDecRNNTModel):
-            self.decoder_type = "rnnt"
-        else:
-            raise ValueError("Decoder type not supported for this model.")
-
-        if self.att_context_size is not None:
-            if hasattr(asr_model.encoder, "set_default_att_context_size"):
-                asr_model.encoder.set_default_att_context_size(att_context_size=self.att_context_size)
-            else:
-                raise ValueError("Model does not support multiple lookaheads.")
-        else:
-            self.att_context_size = asr_model.cfg.encoder.att_context_size
-
-        decoding_cfg = asr_model.cfg.decoding
-        with open_dict(decoding_cfg):
-            decoding_cfg.strategy = "greedy"
-            decoding_cfg.compute_timestamps = False
-            decoding_cfg.preserve_alignments = True
-            if hasattr(asr_model, 'joint'):  # if an RNNT model
-                decoding_cfg.greedy.max_symbols = 10
-                decoding_cfg.fused_batch_size = -1
-            asr_model.change_decoding_strategy(decoding_cfg)
-
-        if hasattr(asr_model.encoder, "set_default_att_context_size"):
-            asr_model.encoder.set_default_att_context_size(att_context_size=self.att_context_size)
-
-        # chunk_size is set automatically for models trained for streaming.
-        # For models trained for offline mode with full context, we need to pass the chunk_size explicitly.
-        if self.chunk_size > 0:
-            if self.shift_size < 0:
-                shift_size = self.chunk_size
-            else:
-                shift_size = self.shift_size
-            asr_model.encoder.setup_streaming_params(
-                chunk_size=self.chunk_size, left_chunks=self.left_chunks, shift_size=shift_size
-            )
-
-        asr_model.eval()
-        return asr_model
-
-    def _get_best_hypothesis(self, encoded, encoded_len, partial_hypotheses=None):
-        if self.decoder_type == "ctc":
-            best_hyp = self.asr_model.decoding.ctc_decoder_predictions_tensor(
-                encoded,
-                encoded_len,
-                return_hypotheses=True,
-            )
-        elif self.decoder_type == "rnnt":
-            best_hyp = self.asr_model.decoding.rnnt_decoder_predictions_tensor(
-                encoded, encoded_len, return_hypotheses=True, partial_hypotheses=partial_hypotheses
-            )
-        else:
-            raise ValueError("Decoder type not supported for this model.")
-        return best_hyp
-
-    def _get_tokens_and_probs_from_alignments(self, alignments):
-        tokens = []
-        probs = []
-        if self.decoder_type == "ctc":
-            all_logits = alignments[0]
-            all_tokens = alignments[1]
-            for i in range(len(all_tokens)):
-                token_id = int(all_tokens[i])
-                if token_id != self.blank_id:
-                    tokens.append(token_id)
-                    logits = all_logits[i]  # shape (vocab_size,)
-                    probs_i = torch.softmax(logits, dim=-1)[token_id].item()
-                    probs.append(probs_i)
-        elif self.decoder_type == "rnnt":
-            for t in range(len(alignments)):
-                for u in range(len(alignments[t])):
-                    logits, token_id = alignments[t][u]  # (logits, token_id)
-                    token_id = int(token_id)
-                    if token_id != self.blank_id:
-                        tokens.append(token_id)
-                        probs_i = torch.softmax(logits, dim=-1)[token_id].item()
-                        probs.append(probs_i)
-        else:
-            raise ValueError("Decoder type not supported for this model.")
-
-        return tokens, probs
-
-    def transcribe(self, audio: bytes, stream_id: str = "default") -> ASRResult:
-        start_time = time.time()
-
-        # Convert bytes to numpy array
-        audio_array = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / 32768.0
-
-        self._audio_buffer.update(audio_array)
-
-        features = self._audio_buffer.get_feature_buffer()
-        feature_lengths = torch.tensor([features.shape[1]], device=self.device)
-        features = features.unsqueeze(0)  # Add batch dimension
-
-        with torch.no_grad():
-            (
-                encoded,
-                encoded_len,
-                cache_last_channel,
-                cache_last_time,
-                cache_last_channel_len,
-            ) = self.asr_model.encoder.cache_aware_stream_step(
-                processed_signal=features,
-                processed_signal_length=feature_lengths,
-                cache_last_channel=self._cache_last_channel,
-                cache_last_time=self._cache_last_time,
-                cache_last_channel_len=self._cache_last_channel_len,
-                keep_all_outputs=False,
-                drop_extra_pre_encoded=self.drop_extra_pre_encoded,
-            )
-
-        best_hyp = self._get_best_hypothesis(encoded, encoded_len, partial_hypotheses=self._previous_hypotheses)
-
-        self._previous_hypotheses = best_hyp
-        self._cache_last_channel = cache_last_channel
-        self._cache_last_time = cache_last_time
-        self._cache_last_channel_len = cache_last_channel_len
-
-        tokens, probs = self._get_tokens_and_probs_from_alignments(best_hyp[0].alignments)
-
-        text = self.get_text_from_tokens(tokens)
-
-        is_final = False
-        eou_latency = None
-        eob_latency = None
-        eou_prob = None
-        eob_prob = None
-        current_timestamp = time.time()
-        if self.eou_string in text or self.eob_string in text:
-            is_final = True
-            if self.eou_string in text:
-                eou_latency = (
-                    current_timestamp - self._last_transcript_timestamp if text.strip() == self.eou_string else 0.0
-                )
-                eou_prob = self.get_eou_probability(tokens, probs, self.eou_string)
-            if self.eob_string in text:
-                eob_latency = (
-                    current_timestamp - self._last_transcript_timestamp if text.strip() == self.eob_string else 0.0
-                )
-                eob_prob = self.get_eou_probability(tokens, probs, self.eob_string)
-            self.reset_state(stream_id=stream_id)
-        if text.strip():
-            self._last_transcript_timestamp = current_timestamp
-
-        processing_time = time.time() - start_time
-        return ASRResult(
-            text=text,
-            is_final=is_final,
-            eou_latency=eou_latency,
-            eob_latency=eob_latency,
-            eou_prob=eou_prob,
-            eob_prob=eob_prob,
-            processing_time=processing_time,
-        )
-
-    def reset_state(self, stream_id: str = "default"):
-        self._audio_buffer.reset()
-        self._reset_cache()
-        self._previous_hypotheses = self._get_blank_hypothesis()
-        self._last_transcript_timestamp = time.time()
-
-    def get_eou_probability(self, tokens: List[int], probs: List[float], eou_string: str = "<EOU>") -> float:
-        text_tokens = self.tokenizer.ids_to_tokens(tokens)
-        eou_index = text_tokens.index(eou_string)
-        return probs[eou_index]

nemo/agents/voice_agent/pipecat/services/nemo/streaming_diar.py

@@ -1,212 +0,0 @@
-# Copyright (c) 2025, 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.
-# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
-
-from dataclasses import dataclass
-from typing import Tuple
-
-import numpy as np
-import torch
-from torch import Tensor
-
-from nemo.agents.voice_agent.pipecat.services.nemo.utils import CacheFeatureBufferer
-from nemo.collections.asr.models import SortformerEncLabelModel
-
-from nemo.collections.asr.modules.sortformer_modules import StreamingSortformerState
-
-
-@dataclass
-class DiarizationConfig:
-    """Diarization configuration parameters for inference."""
-
-    model_path: str = "nvidia/diar_streaming_sortformer_4spk-v2"
-    device: str = "cuda"
-
-    log: bool = False  # If True, log will be printed
-    max_num_speakers: int = 4
-    spkcache_len: int = 188
-    spkcache_refresh_rate: int = 144
-    fifo_len: int = 188
-    chunk_len: int = 6
-    chunk_left_context: int = 1
-    chunk_right_context: int = 7
-
-
-class NeMoStreamingDiarService:
-    def __init__(
-        self,
-        cfg: DiarizationConfig,
-        model: str,
-        frame_len_in_secs: float = 0.08,
-        sample_rate: int = 16000,
-        left_offset: int = 8,
-        right_offset: int = 8,
-        use_amp: bool = False,
-        compute_dtype: torch.dtype = torch.float32,
-    ):
-        self.model = model
-        self.cfg = cfg
-        self.cfg.model_path = model
-        self.diarizer = self.build_diarizer()
-        self.device = cfg.device
-        self.use_amp = use_amp
-        self.compute_dtype = compute_dtype
-        self.frame_len_in_secs = frame_len_in_secs
-        self.left_offset = left_offset
-        self.right_offset = right_offset
-        self.chunk_size = self.cfg.chunk_len
-        self.buffer_size_in_secs = (
-            self.cfg.chunk_len * self.frame_len_in_secs + (self.left_offset + self.right_offset) * 0.01
-        )
-        self.max_num_speakers = self.cfg.max_num_speakers
-
-        self.feature_bufferer = CacheFeatureBufferer(
-            sample_rate=sample_rate,
-            buffer_size_in_secs=self.buffer_size_in_secs,
-            chunk_size_in_secs=self.cfg.chunk_len * self.frame_len_in_secs,
-            preprocessor_cfg=self.diarizer.cfg.preprocessor,
-            device=self.device,
-        )
-        self.streaming_state = self.init_streaming_state(batch_size=1)
-        self.total_preds = torch.zeros((1, 0, self.max_num_speakers), device=self.diarizer.device)
-
-        print(f"NeMoStreamingDiarService initialized with model `{model}` on device `{self.device}`")
-
-    def build_diarizer(self):
-        if self.cfg.model_path.endswith(".nemo"):
-            diar_model = SortformerEncLabelModel.restore_from(self.cfg.model_path, map_location=self.cfg.device)
-        else:
-            diar_model = SortformerEncLabelModel.from_pretrained(self.cfg.model_path, map_location=self.cfg.device)
-
-        # Steaming mode setup
-        diar_model.sortformer_modules.chunk_len = self.cfg.chunk_len
-        diar_model.sortformer_modules.spkcache_len = self.cfg.spkcache_len
-        diar_model.sortformer_modules.chunk_left_context = self.cfg.chunk_left_context
-        diar_model.sortformer_modules.chunk_right_context = self.cfg.chunk_right_context
-        diar_model.sortformer_modules.fifo_len = self.cfg.fifo_len
-        diar_model.sortformer_modules.log = self.cfg.log
-        diar_model.sortformer_modules.spkcache_refresh_rate = self.cfg.spkcache_refresh_rate
-        diar_model.eval()
-
-        return diar_model
-
-    def print_diar_result(self, diar_result: np.ndarray):
-        for t in range(diar_result.shape[0]):
-            spk_probs = ""
-            for s in range(diar_result.shape[1]):
-                spk_probs += f"{diar_result[t, s]:.2f} "
-            print(f"Time {t}: {spk_probs}")
-
-    def diarize(self, audio: bytes, stream_id: str = "default") -> str:
-
-        audio_array = np.frombuffer(audio, dtype=np.int16).astype(np.float32) / 32768.0
-
-        self.feature_bufferer.update(audio_array)
-
-        features = self.feature_bufferer.get_feature_buffer()
-        feature_buffers = features.unsqueeze(0)  # add batch dimension
-        feature_buffers = feature_buffers.transpose(1, 2)  # [batch, feature, time] -> [batch, time, feature]
-        feature_buffer_lens = torch.tensor([feature_buffers.shape[1]], device=self.device)
-        self.streaming_state, chunk_preds = self.stream_step(
-            processed_signal=feature_buffers,
-            processed_signal_length=feature_buffer_lens,
-            streaming_state=self.streaming_state,
-            total_preds=self.total_preds,
-            left_offset=self.left_offset,
-            right_offset=self.right_offset,
-        )
-        self.total_preds = chunk_preds
-        diar_result = chunk_preds[:, -self.chunk_size :, :].clone().cpu().numpy()
-        return diar_result[0]  # tensor of shape [6, 4]
-
-    def reset_state(self, stream_id: str = "default"):
-        self.feature_bufferer.reset()
-        self.streaming_state = self.init_streaming_state(batch_size=1)
-        self.total_preds = torch.zeros((1, 0, self.max_num_speakers), device=self.diarizer.device)
-
-    def init_streaming_state(self, batch_size: int = 1) -> StreamingSortformerState:
-        """
-        Initialize the streaming state for the diarization model.
-
-        Args:
-            batch_size: The batch size to use.
-
-        Returns:
-            SortformerStreamingState: The initialized streaming state.
-        """
-        # Use the model's init_streaming_state method but convert to SortformerStreamingState format
-        nemo_state = self.diarizer.sortformer_modules.init_streaming_state(
-            batch_size=batch_size, async_streaming=self.diarizer.async_streaming, device=self.device
-        )
-
-        return nemo_state
-
-    def stream_step(
-        self,
-        processed_signal: Tensor,
-        processed_signal_length: Tensor,
-        streaming_state: StreamingSortformerState,
-        total_preds: Tensor,
-        left_offset: int = 0,
-        right_offset: int = 0,
-    ) -> Tuple[StreamingSortformerState, Tensor]:
-        """
-        Execute a single streaming step for diarization.
-
-        Args:
-            processed_signal: The processed audio signal.
-            processed_signal_length: The length of the processed signal.
-            streaming_state: The current streaming state.
-            total_preds: The total predictions so far.
-            left_offset: The left offset for the current chunk.
-            right_offset: The right offset for the current chunk.
-
-        Returns:
-            Tuple[SortformerStreamingState, Tensor]: The updated streaming state and predictions.
-        """
-        # Move tensors to correct device
-        if processed_signal.device != self.device:
-            processed_signal = processed_signal.to(self.device)
-
-        if processed_signal_length.device != self.device:
-            processed_signal_length = processed_signal_length.to(self.device)
-
-        if total_preds is not None and total_preds.device != self.device:
-            total_preds = total_preds.to(self.device)
-
-        with (
-            torch.amp.autocast(device_type=self.device, dtype=self.compute_dtype, enabled=self.use_amp),
-            torch.inference_mode(),
-            torch.no_grad(),
-        ):
-            try:
-                # Call the model's forward_streaming_step method
-                streaming_state, diar_pred_out_stream = self.diarizer.forward_streaming_step(
-                    processed_signal=processed_signal,
-                    processed_signal_length=processed_signal_length,
-                    streaming_state=streaming_state,
-                    total_preds=total_preds,
-                    left_offset=left_offset,
-                    right_offset=right_offset,
-                )
-            except Exception as e:
-                print(f"Error in diarizer streaming step: {e}")
-                # print the stack trace
-                import traceback
-
-                traceback.print_exc()
-                # Return the existing state and preds if there's an error
-                return streaming_state, total_preds
-
-        return streaming_state, diar_pred_out_stream

nemo/agents/voice_agent/pipecat/services/nemo/stt.py

@@ -1,316 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-from datetime import datetime
-from typing import AsyncGenerator, List, Optional
-
-from loguru import logger
-from pipecat.frames.frames import (
-    CancelFrame,
-    EndFrame,
-    ErrorFrame,
-    Frame,
-    InterimTranscriptionFrame,
-    StartFrame,
-    TranscriptionFrame,
-    VADUserStartedSpeakingFrame,
-    VADUserStoppedSpeakingFrame,
-)
-from pipecat.processors.frame_processor import FrameDirection
-from pipecat.services.stt_service import STTService
-from pipecat.transcriptions.language import Language
-from pipecat.utils.time import time_now_iso8601
-from pipecat.utils.tracing.service_decorators import traced_stt
-from pydantic import BaseModel
-
-from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
-from nemo.agents.voice_agent.pipecat.services.nemo.streaming_asr import NemoStreamingASRService
-
-ASR_EOU_MODELS = ["nvidia/parakeet_realtime_eou_120m-v1"]
-
-try:
-    # disable nemo logging
-    from nemo.utils import logging
-
-    level = logging.getEffectiveLevel()
-    logging.setLevel(logging.CRITICAL)
-
-
-except ModuleNotFoundError as e:
-    logger.error(f"Exception: {e}")
-    logger.error('In order to use NVIDIA NeMo STT, you need to `pip install "nemo_toolkit[all]"`.')
-    raise Exception(f"Missing module: {e}")
-
-
-class NeMoSTTInputParams(BaseModel):
-    """Input parameters for NeMo STT service."""
-
-    language: Optional[Language] = Language.EN_US
-    att_context_size: Optional[List] = [70, 1]
-    frame_len_in_secs: Optional[float] = 0.08  # 80ms for FastConformer model
-    config_path: Optional[str] = None  # path to the Niva ASR config file
-    raw_audio_frame_len_in_secs: Optional[float] = 0.016  # 16ms for websocket transport
-    buffer_size: Optional[int] = 5  # number of audio frames to buffer, 1 frame is 16ms
-
-
-class NemoSTTService(STTService):
-    """NeMo Speech-to-Text service for Pipecat integration."""
-
-    def __init__(
-        self,
-        *,
-        model: Optional[str] = "nnvidia/parakeet_realtime_eou_120m-v1",
-        device: Optional[str] = "cuda:0",
-        sample_rate: Optional[int] = 16000,
-        params: Optional[NeMoSTTInputParams] = None,
-        has_turn_taking: Optional[bool] = None,  # if None, it will be set by the model name
-        backend: Optional[str] = "legacy",
-        decoder_type: Optional[str] = "rnnt",
-        audio_logger: Optional[AudioLogger] = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self._queue = asyncio.Queue()
-        self._sample_rate = sample_rate
-        self._params = params or NeMoSTTInputParams()
-        self._model_name = model
-        if has_turn_taking is None:
-            has_turn_taking = True if model in ASR_EOU_MODELS else False
-            logger.info(f"Setting has_turn_taking to `{has_turn_taking}` based on model name: `{model}`")
-        self._has_turn_taking = has_turn_taking
-        self._backend = backend
-        self._decoder_type = decoder_type
-        self._audio_logger = audio_logger
-        self._is_vad_active = False
-        logger.info(f"NeMoSTTInputParams: {self._params}")
-
-        self._device = device
-
-        self._load_model()
-
-        self.audio_buffer = []
-        self.user_is_speaking = False
-
-    def _load_model(self):
-        if self._backend == "legacy":
-            self._model = NemoStreamingASRService(
-                self._model_name,
-                self._params.att_context_size,
-                device=self._device,
-                decoder_type=self._decoder_type,
-                frame_len_in_secs=self._params.frame_len_in_secs,
-            )
-        else:
-            raise ValueError(f"Invalid ASR backend: {self._backend}")
-
-    def can_generate_metrics(self) -> bool:
-        """Indicates whether this service can generate metrics.
-
-        Returns:
-            bool: True, as this service supports metric generation.
-        """
-        return True
-
-    async def start(self, frame: StartFrame):
-        """Handle service start.
-
-        Args:
-            frame: StartFrame containing initial configuration
-        """
-        await super().start(frame)
-
-        # Initialize the model if not already done
-        if not hasattr(self, "_model"):
-            self._load_model()
-
-    async def stop(self, frame: EndFrame):
-        """Handle service stop.
-
-        Args:
-            frame: EndFrame that triggered this method
-        """
-        await super().stop(frame)
-        # Clear any internal state if needed
-        await self._queue.put(None)  # Signal to stop processing
-
-    async def cancel(self, frame: CancelFrame):
-        """Handle service cancellation.
-
-        Args:
-            frame: CancelFrame that triggered this method
-        """
-        await super().cancel(frame)
-        # Clear any internal state
-        await self._queue.put(None)  # Signal to stop processing
-        self._queue = asyncio.Queue()  # Reset the queue
-
-    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
-        """Process audio data and generate transcription frames.
-
-        Args:
-            audio: Raw audio bytes to transcribe
-
-        Yields:
-            Frame: Transcription frames containing the results
-        """
-        timestamp_now = datetime.now()
-        await self.start_ttfb_metrics()
-        await self.start_processing_metrics()
-        if self._audio_logger is not None and self._audio_logger.first_audio_timestamp is None:
-            self._audio_logger.first_audio_timestamp = timestamp_now
-
-        try:
-            is_final = False
-            user_has_finished = False
-            transcription = None
-            self.audio_buffer.append(audio)
-            if len(self.audio_buffer) >= self._params.buffer_size:
-                audio = b"".join(self.audio_buffer)
-                self.audio_buffer = []
-
-                # Append to continuous user audio buffer for stereo conversation recording
-                if self._audio_logger is not None:
-                    self._audio_logger.append_continuous_user_audio(audio)
-
-                asr_result = self._model.transcribe(audio)
-                transcription = asr_result.text
-                is_final = asr_result.is_final
-                if self._audio_logger is not None:
-                    if self._is_vad_active:
-                        is_first_frame = False
-                        self._audio_logger.turn_audio_buffer.append(audio)
-                        # Accumulate transcriptions for turn-based logging
-                        if transcription:
-                            self._audio_logger.turn_transcription_buffer.append(transcription)
-                            self._audio_logger.stage_turn_audio_and_transcription(
-                                timestamp_now=timestamp_now,
-                                is_first_frame=is_first_frame,
-                                additional_metadata={
-                                    "model": self._model_name,
-                                    "backend": self._backend,
-                                },
-                            )
-                eou_latency = asr_result.eou_latency
-                eob_latency = asr_result.eob_latency
-                eou_prob = asr_result.eou_prob
-                eob_prob = asr_result.eob_prob
-                if eou_latency is not None:
-                    logger.debug(
-                        f"EOU latency: {eou_latency: .4f} seconds. EOU probability: {eou_prob: .2f}."
-                        f"Processing time: {asr_result.processing_time: .4f} seconds."
-                    )
-                    user_has_finished = True
-                if eob_latency is not None:
-                    logger.debug(
-                        f"EOB latency: {eob_latency: .4f} seconds. EOB probability: {eob_prob: .2f}."
-                        f"Processing time: {asr_result.processing_time: .4f} seconds."
-                    )
-                    user_has_finished = True
-                await self.stop_ttfb_metrics()
-                await self.stop_processing_metrics()
-
-            if transcription:
-                logger.debug(f"Transcription (is_final={is_final}): `{transcription}`")
-                self.user_is_speaking = True if not user_has_finished else False
-
-                # Get the language from params or default to EN_US
-                language = self._params.language if self._params else Language.EN_US
-
-                # Create and push the transcription frame
-                if self._has_turn_taking:
-                    # if turn taking is enabled, we push interim transcription frames
-                    # and let the turn taking service handle the final transcription
-                    frame_type = InterimTranscriptionFrame
-                else:
-                    # otherwise, we use the is_final flag to determine the frame type
-                    frame_type = TranscriptionFrame if is_final else InterimTranscriptionFrame
-                await self.push_frame(
-                    frame_type(
-                        transcription,
-                        "",  # No speaker ID in this implementation
-                        time_now_iso8601(),
-                        language,
-                        result={"text": transcription},
-                    )
-                )
-
-                # Handle the transcription
-                await self._handle_transcription(
-                    transcript=transcription,
-                    is_final=is_final,
-                    language=language,
-                )
-
-            yield None
-
-        except Exception as e:
-            logger.error(f"Error in NeMo STT processing: {e}")
-            await self.push_frame(
-                ErrorFrame(
-                    str(e),
-                    time_now_iso8601(),
-                )
-            )
-            yield None
-
-    @traced_stt
-    async def _handle_transcription(self, transcript: str, is_final: bool, language: Optional[str] = None):
-        """Handle a transcription result.
-
-        Args:
-            transcript: The transcribed text
-            is_final: Whether this is a final transcription
-            language: The language of the transcription
-        """
-        pass  # Base implementation - can be extended for specific handling needs
-
-    async def set_language(self, language: Language):
-        """Update the service's recognition language.
-
-        Args:
-            language: New language for recognition
-        """
-        if self._params:
-            self._params.language = language
-        else:
-            self._params = NeMoSTTInputParams(language=language)
-
-        logger.info(f"Switching STT language to: {language}")
-
-    async def set_model(self, model: str):
-        """Update the service's model.
-
-        Args:
-            model: New model name/path to use
-        """
-        await super().set_model(model)
-        self._model_name = model
-        self._load_model()
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        """Process incoming frames and handle VAD events."""
-        if isinstance(frame, VADUserStoppedSpeakingFrame) and isinstance(self._model, NemoStreamingASRService):
-            # manualy reset the state of the model when end of utterance is detected by VAD
-            logger.debug("Resetting state of the model due to VADUserStoppedSpeakingFrame")
-            if self.user_is_speaking:
-                logger.debug(
-                    "[EOU missing] STT failed to detect end of utterance before VAD detected user stopped speaking"
-                )
-            self._model.reset_state()
-            self._is_vad_active = False
-        elif isinstance(frame, VADUserStartedSpeakingFrame):
-            self._is_vad_active = True
-
-        await super().process_frame(frame, direction)

nemo/agents/voice_agent/pipecat/services/nemo/tts.py

@@ -1,892 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-import inspect
-import uuid
-from collections.abc import AsyncGenerator
-from datetime import datetime
-from typing import Iterator, List, Optional
-
-import numpy as np
-import torch
-from loguru import logger
-from omegaconf import DictConfig, OmegaConf
-from pipecat.frames.frames import (
-    CancelFrame,
-    EndFrame,
-    ErrorFrame,
-    Frame,
-    LLMTextFrame,
-    StartFrame,
-    TTSAudioRawFrame,
-    TTSStartedFrame,
-    TTSStoppedFrame,
-)
-from pipecat.services.llm_service import FunctionCallParams
-from pipecat.services.tts_service import TTSService
-
-from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
-from nemo.agents.voice_agent.pipecat.utils.text.simple_text_aggregator import SimpleSegmentedTextAggregator
-from nemo.agents.voice_agent.utils.tool_calling.mixins import ToolCallingMixin
-from nemo.collections.tts.models import FastPitchModel, HifiGanModel
-
-
-class BaseNemoTTSService(TTSService, ToolCallingMixin):
-    """Text-to-Speech service using Nemo TTS models.
-
-    This service works with any TTS model that exposes a generate(text) method
-    that returns audio data. The TTS generation runs in a dedicated background thread to
-    avoid blocking the main asyncio event loop, following the same pattern as NemoDiarService.
-
-    Args:
-        model: TTS model instance with a generate(text) method
-        sample_rate: Audio sample rate in Hz (defaults to 22050)
-        **kwargs: Additional arguments passed to TTSService
-    """
-
-    def __init__(
-        self,
-        *,
-        model,
-        device: str = "cuda",
-        sample_rate: int = 22050,
-        think_tokens: Optional[List[str]] = None,
-        audio_logger: Optional[AudioLogger] = None,
-        ignore_strings: Optional[List[str]] = None,
-        **kwargs,
-    ):
-        super().__init__(sample_rate=sample_rate, **kwargs)
-        logger.info(f"Initializing TTS service with model: {model} and device: {device}")
-        self._model_name = model
-        self._device = device
-        self._model = self._setup_model()
-        self._think_tokens = think_tokens
-        self._audio_logger = audio_logger
-        if think_tokens is not None:
-            assert (
-                isinstance(think_tokens, list) and len(think_tokens) == 2
-            ), f"think_tokens must be a list of two strings, but got type {type(think_tokens)}: {think_tokens}"
-        self._ignore_strings = set(ignore_strings) if ignore_strings is not None else None
-        # Background processing infrastructure - no response handler needed
-        self._tts_queue = asyncio.Queue()
-        self._processing_task = None
-        self._processing_running = False
-
-        # Track pending requests with their response queues
-        self._pending_requests = {}
-        self._have_seen_think_tokens = False
-
-    def reset(self):
-        """Reset the TTS service."""
-        self._text_aggregator.reset()
-
-    def setup_tool_calling(self):
-        """
-        Setup the tool calling mixin by registering all available tools.
-        """
-        pass  # No tools by default
-
-    def _setup_model(self):
-        raise NotImplementedError("Subclass must implement _setup_model")
-
-    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
-        raise NotImplementedError("Subclass must implement _generate_audio")
-
-    def can_generate_metrics(self) -> bool:
-        """If the TTS service can generate metrics."""
-        return True
-
-    async def start(self, frame: StartFrame):
-        """Handle service start."""
-        await super().start(frame)
-
-        # Initialize the model if not already done
-        if not hasattr(self, "_model") or self._model is None:
-            self._model = self._setup_model()
-
-        # Only start background processing task - no response handler needed
-        if not self._processing_task:
-            self._processing_task = self.create_task(self._processing_task_handler())
-
-    async def stop(self, frame: EndFrame):
-        """Handle service stop."""
-        await super().stop(frame)
-        await self._stop_tasks()
-
-    async def cancel(self, frame: CancelFrame):
-        """Handle service cancellation."""
-        await super().cancel(frame)
-        await self._stop_tasks()
-
-    async def _stop_tasks(self):
-        """Stop background processing tasks."""
-        self._processing_running = False
-        await self._tts_queue.put(None)  # Signal to stop processing
-
-        if self._processing_task:
-            await self.cancel_task(self._processing_task)
-            self._processing_task = None
-
-    def _tts_processor(self):
-        """Background processor that handles TTS generation calls."""
-        try:
-            while self._processing_running:
-                try:
-                    future = asyncio.run_coroutine_threadsafe(self._tts_queue.get(), self.get_event_loop())
-                    request = future.result()
-
-                    if request is None:  # Stop signal
-                        logger.debug("Received stop signal in TTS background processor")
-                        break
-
-                    text, request_id = request
-                    logger.debug(f"Processing TTS request for text: [{text}]")
-
-                    # Get the response queue for this request
-                    response_queue = None
-                    future = asyncio.run_coroutine_threadsafe(
-                        self._get_response_queue(request_id), self.get_event_loop()
-                    )
-                    response_queue = future.result()
-
-                    if response_queue is None:
-                        logger.warning(f"No response queue found for request {request_id}")
-                        continue
-
-                    # Process TTS generation
-                    try:
-                        audio_result = self._generate_audio(text)
-
-                        # Send result directly to the waiting request
-                        asyncio.run_coroutine_threadsafe(
-                            response_queue.put(('success', audio_result)), self.get_event_loop()
-                        )
-                    except Exception as e:
-                        logger.error(f"Error in TTS generation: {e}")
-                        # Send error directly to the waiting request
-                        asyncio.run_coroutine_threadsafe(response_queue.put(('error', e)), self.get_event_loop())
-
-                except Exception as e:
-                    logger.error(f"Error in background TTS processor: {e}")
-
-        except Exception as e:
-            logger.error(f"Background TTS processor fatal error: {e}")
-        finally:
-            logger.debug("Background TTS processor stopped")
-
-    async def _get_response_queue(self, request_id: str):
-        """Get the response queue for a specific request."""
-        return self._pending_requests.get(request_id)
-
-    async def _processing_task_handler(self):
-        """Handler for background processing task."""
-        try:
-            self._processing_running = True
-            logger.debug("Starting background TTS processing task")
-            await asyncio.to_thread(self._tts_processor)
-        except asyncio.CancelledError:
-            logger.debug("Background TTS processing task cancelled")
-            self._processing_running = False
-            raise
-        finally:
-            self._processing_running = False
-
-    def _handle_think_tokens(self, text: str) -> Optional[str]:
-        """
-        Handle the thinking tokens for TTS.
-        If the thinking tokens are not provided, return the text as it is.
-        Otherwise:
-            If both thinking tokens appear in the text, return the text after the end of thinking tokens.
-            If the LLM is thinking, return None.
-            If the LLM is done thinking, return the text after the end of thinking tokens.
-            If the LLM starts thinking, return the text before the start of thinking tokens.
-            If the LLM is not thinking, return the text as is.
-        """
-        if not self._think_tokens or not text:
-            return text
-        elif self._think_tokens[0] in text and self._think_tokens[1] in text:
-            # LLM finishes thinking in one chunk or outputs dummy thinking tokens
-            logger.debug(f"LLM finishes thinking: {text}")
-            idx = text.index(self._think_tokens[1])
-            # only return the text after the end of thinking tokens
-            text = text[idx + len(self._think_tokens[1]) :]
-            self._have_seen_think_tokens = False
-            logger.debug(f"Returning text after thinking: {text}")
-            return text
-        elif self._have_seen_think_tokens:
-            # LLM is thinking
-            if self._think_tokens[1] not in text:
-                logger.debug(f"LLM is still thinking: {text}")
-                # LLM is still thinking
-                return None
-            else:
-                # LLM is done thinking
-                logger.debug(f"LLM is done thinking: {text}")
-                idx = text.index(self._think_tokens[1])
-                # only return the text after the end of thinking tokens
-                text = text[idx + len(self._think_tokens[1]) :]
-                self._have_seen_think_tokens = False
-                logger.debug(f"Returning text after thinking: {text}")
-                return text
-        elif self._think_tokens[0] in text:
-            # LLM now starts thinking
-            logger.debug(f"LLM starts thinking: {text}")
-            self._have_seen_think_tokens = True
-            # return text before the start of thinking tokens
-            idx = text.index(self._think_tokens[0])
-            text = text[:idx]
-            logger.debug(f"Returning text before thinking: {text}")
-            return text
-        else:
-            # LLM is not thinking
-            return text
-
-    def _drop_special_tokens(self, text: str) -> Optional[str]:
-        """
-        Drop the special tokens from the text.
-        """
-        if self._ignore_strings is None:
-            return text
-        for ignore_string in self._ignore_strings:
-            if ignore_string in text:
-                logger.debug(f"Dropping string `{ignore_string}` from text: `{text}`")
-                text = text.replace(ignore_string, "")
-        return text
-
-    async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
-        """Generate speech from text using the Nemo TTS model."""
-
-        if self._think_tokens is not None:
-            text = self._handle_think_tokens(text)
-
-        if not text:
-            yield None
-            return
-
-        if self._ignore_strings is not None:
-            text = self._drop_special_tokens(text)
-
-        logger.debug(f"{self}: Generating TTS [{text}]")
-
-        try:
-            await self.start_ttfb_metrics()
-            yield TTSStartedFrame()
-
-            # Increment turn index at the start of agent speaking (only if speaker changed)
-            if self._audio_logger is not None:
-                self._audio_logger.increment_turn_index(speaker="agent")
-
-            # Generate unique request ID
-
-            request_id = str(uuid.uuid4())
-
-            # Create response queue for this specific request
-            request_queue = asyncio.Queue()
-            self._pending_requests[request_id] = request_queue
-
-            try:
-                # Queue the TTS request for background processing
-                await self._tts_queue.put((text, request_id))
-
-                # Wait for the result directly from our request queue
-                result = await request_queue.get()
-                status, data = result
-
-                if status == 'error':
-                    logger.error(f"{self} TTS generation error: {data}")
-                    yield ErrorFrame(error=f"TTS generation error: {str(data)}")
-                    return
-
-                audio_result = data
-                if audio_result is None:
-                    logger.error(f"{self} TTS model returned None for text: [{text}]")
-                    yield ErrorFrame(error="TTS generation failed - no audio returned")
-                    return
-
-                await self.start_tts_usage_metrics(text)
-
-                # Collect all audio for logging
-                all_audio_bytes = b""
-                # Capture the start time when TTS begins (not when it ends)
-                if self._audio_logger is not None and self._audio_logger.first_audio_timestamp is None:
-                    self._audio_logger.first_audio_timestamp = datetime.now()
-
-                # Process the audio result (same as before)
-                if (
-                    inspect.isgenerator(audio_result)
-                    or hasattr(audio_result, '__iter__')
-                    and hasattr(audio_result, '__next__')
-                ):
-                    # Handle generator case
-                    first_chunk = True
-                    for audio_chunk in audio_result:
-                        if first_chunk:
-                            await self.stop_ttfb_metrics()
-                            first_chunk = False
-                            # Capture start time on first chunk
-                            if self._audio_logger is not None:
-                                tts_start_time = self._audio_logger.get_time_from_start_of_session()
-
-                        if audio_chunk is None:
-                            break
-
-                        audio_bytes = self._convert_to_bytes(audio_chunk)
-                        all_audio_bytes += audio_bytes
-                        chunk_size = self.chunk_size
-                        for i in range(0, len(audio_bytes), chunk_size):
-                            audio_chunk_bytes = audio_bytes[i : i + chunk_size]
-                            if not audio_chunk_bytes:
-                                break
-
-                            frame = TTSAudioRawFrame(
-                                audio=audio_chunk_bytes, sample_rate=self.sample_rate, num_channels=1
-                            )
-                            yield frame
-                else:
-                    # Handle single result case
-                    await self.stop_ttfb_metrics()
-                    # Capture start time for single result
-                    if self._audio_logger is not None:
-                        tts_start_time = self._audio_logger.get_time_from_start_of_session()
-                    audio_bytes = self._convert_to_bytes(audio_result)
-                    all_audio_bytes = audio_bytes
-
-                    chunk_size = self.chunk_size
-                    for i in range(0, len(audio_bytes), chunk_size):
-                        chunk = audio_bytes[i : i + chunk_size]
-                        if not chunk:
-                            break
-
-                        frame = TTSAudioRawFrame(audio=chunk, sample_rate=self.sample_rate, num_channels=1)
-                        yield frame
-
-                # Log the complete audio if logger is available
-                if self._audio_logger is not None and all_audio_bytes:
-                    try:
-                        self._audio_logger.log_agent_audio(
-                            audio_data=all_audio_bytes,
-                            text=text,
-                            sample_rate=self.sample_rate,
-                            num_channels=1,
-                            additional_metadata={
-                                "model": self._model_name,
-                            },
-                            tts_generation_time=tts_start_time,
-                        )
-                    except Exception as e:
-                        logger.warning(f"Failed to log agent audio: {e}")
-
-                yield TTSStoppedFrame()
-
-            finally:
-                # Clean up the pending request
-                if request_id in self._pending_requests:
-                    del self._pending_requests[request_id]
-
-        except Exception as e:
-            logger.exception(f"{self} error generating TTS: {e}")
-            error_message = f"TTS generation error: {str(e)}"
-            yield ErrorFrame(error=error_message)
-
-    def _convert_to_bytes(self, audio_data) -> bytes:
-        """Convert various audio data formats to bytes."""
-        if isinstance(audio_data, (bytes, bytearray)):
-            return bytes(audio_data)
-
-        if isinstance(audio_data, np.ndarray):
-            # Ensure it's in the right format (16-bit PCM)
-            if audio_data.dtype in [np.float32, np.float64]:
-                # Convert float [-1, 1] to int16 [-32768, 32767]
-                audio_data = np.clip(audio_data, -1.0, 1.0)  # Ensure values are in range
-                audio_data = (audio_data * 32767).astype(np.int16)
-            elif audio_data.dtype != np.int16:
-                # Convert other integer types to int16
-                audio_data = audio_data.astype(np.int16)
-            return audio_data.tobytes()
-        elif hasattr(audio_data, 'tobytes'):
-            return audio_data.tobytes()
-        else:
-            return bytes(audio_data)
-
-
-class NeMoFastPitchHiFiGANTTSService(BaseNemoTTSService):
-    """Text-to-Speech service using NeMo FastPitch-Hifigan model.
-
-    More info: https://huggingface.co/nvidia/tts_en_fastpitch
-
-    Args:
-        fastpitch_model: FastPitch model name
-        hifigan_model: Hifigan model name
-        device: Device to run on (default: 'cuda')
-        **kwargs: Additional arguments passed to BaseNemoTTSService
-    """
-
-    def __init__(
-        self,
-        fastpitch_model: str = "nvidia/tts_en_fastpitch",
-        hifigan_model: str = "nvidia/tts_hifigan",
-        device: str = "cuda",
-        **kwargs,
-    ):
-        model_name = f"{fastpitch_model}+{hifigan_model}"
-        self._fastpitch_model_name = fastpitch_model
-        self._hifigan_model_name = hifigan_model
-        super().__init__(model=model_name, device=device, **kwargs)
-        self.setup_tool_calling()
-
-    def _setup_model(self):
-        logger.info(
-            f"Loading FastPitch model={self._fastpitch_model_name} and HiFiGAN model={self._hifigan_model_name}"
-        )
-        self._fastpitch_model = self._setup_fastpitch_model(self._fastpitch_model_name)
-        self._hifigan_model = self._setup_hifigan_model(self._hifigan_model_name)
-        return self._fastpitch_model, self._hifigan_model
-
-    def _setup_fastpitch_model(self, model_name: str):
-        if model_name.endswith(".nemo"):
-            fastpitch_model = FastPitchModel.restore_from(model_name, map_location=torch.device(self._device))
-        else:
-            fastpitch_model = FastPitchModel.from_pretrained(model_name, map_location=torch.device(self._device))
-        fastpitch_model.eval()
-        return fastpitch_model
-
-    def _setup_hifigan_model(self, model_name: str):
-        if model_name.endswith(".nemo"):
-            hifigan_model = HifiGanModel.restore_from(model_name, map_location=torch.device(self._device))
-        else:
-            hifigan_model = HifiGanModel.from_pretrained(model_name, map_location=torch.device(self._device))
-        hifigan_model.eval()
-        return hifigan_model
-
-    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
-        with torch.no_grad():
-            parsed = self._fastpitch_model.parse(text)
-            spectrogram = self._fastpitch_model.generate_spectrogram(tokens=parsed)
-            audio = self._hifigan_model.convert_spectrogram_to_audio(spec=spectrogram)
-            audio = audio.detach().view(-1).cpu().numpy()
-            yield audio
-
-
-class KokoroTTSService(BaseNemoTTSService):
-    """Text-to-Speech service using Kokoro-82M model.
-
-    Kokoro is an open-weight TTS model with 82 million parameters.
-    More info: https://huggingface.co/hexgrad/Kokoro-82M
-
-    Args:
-        lang_code: Language code for the model (default: 'a' for American English)
-        voice: Voice to use (default: 'af_heart')
-        device: Device to run on (default: 'cuda')
-        sample_rate: Audio sample rate in Hz (default: 24000 for Kokoro)
-        download_all: Download all models for different languages (default: True)
-        cache_models: Cache models on GPU for faster switching between languages (default: True)
-        **kwargs: Additional arguments passed to BaseNemoTTSService
-    """
-
-    def __init__(
-        self,
-        model: str = "hexgrad/Kokoro-82M",
-        lang_code: str = "a",
-        voice: str = "af_heart",
-        device: str = "cuda",
-        sample_rate: int = 24000,
-        speed: float = 1.0,
-        download_all: bool = True,
-        cache_models: bool = True,
-        **kwargs,
-    ):
-        self._lang_code = lang_code
-        self._voice = voice
-        self._speed = speed
-        assert speed > 0, "Speed must be greater than 0"
-        self._original_speed = speed
-        self._original_voice = voice
-        self._gender = 'female' if voice[1] == 'f' else 'male'
-        self._original_gender = self._gender
-        self._original_lang_code = self._lang_code
-        if download_all:
-            self._model_maps = self._download_all_models(
-                lang_code=["a", "b"], device=device, repo_id=model, cache_models=cache_models
-            )
-        else:
-            self._model_maps = {}
-        super().__init__(model=model, device=device, sample_rate=sample_rate, **kwargs)
-        self.setup_tool_calling()
-
-    def _setup_model(self, lang_code: Optional[str] = None, voice: Optional[str] = None):
-        """Initialize the Kokoro pipeline."""
-        try:
-            from kokoro import KPipeline
-        except ImportError:
-            raise ImportError(
-                "kokoro package is required for KokoroTTSService. Install it with: `pip install kokoro>=0.9.2`"
-            )
-        if lang_code is None:
-            lang_code = self._lang_code
-        if voice is None:
-            voice = self._voice
-        logger.info(f"Loading Kokoro TTS model with model={self._model_name}, lang_code={lang_code}, voice={voice}")
-        if lang_code in self._model_maps:
-            pipeline = self._model_maps[lang_code]
-        else:
-            pipeline = KPipeline(lang_code=lang_code, device=self._device, repo_id=self._model_name)
-            self._model_maps[lang_code] = pipeline
-        return pipeline
-
-    def _download_all_models(
-        self, lang_code: List[str] = ['a', 'b'], device="cuda", repo_id="hexgrad/Kokoro-82M", cache_models=True
-    ):
-        """Download all models for Kokoro TTS service."""
-        logger.info(f"Downloading all models for Kokoro TTS service with lang_code={lang_code}")
-        from kokoro import KPipeline
-
-        model_maps = {}
-
-        for lang in lang_code:
-            pipeline = KPipeline(lang_code=lang, device=device, repo_id=repo_id)
-            if cache_models:
-                model_maps[lang] = pipeline
-        torch.cuda.empty_cache()
-        return model_maps
-
-    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
-        """Generate audio using the Kokoro pipeline.
-
-        Args:
-            text: Text to convert to speech
-
-        Yields:
-            Audio data as numpy arrays
-        """
-        try:
-            # Generate audio using Kokoro pipeline
-            generator = self._model(text, voice=self._voice, speed=self._speed)
-
-            # The generator yields tuples of (gs, ps, audio)
-            # We only need the audio component
-            for i, (gs, ps, audio) in enumerate(generator):
-                logger.debug(
-                    f"Kokoro generated audio chunk {i}: gs={gs}, ps={ps},"
-                    f"audio_shape={audio.shape if hasattr(audio, 'shape') else len(audio)}"
-                )
-                if isinstance(audio, torch.Tensor):
-                    audio = audio.detach().cpu().numpy()
-                # Kokoro returns audio as numpy array in float32 format [-1, 1]
-                # The base class will handle conversion to int16 bytes
-                yield audio
-
-        except Exception as e:
-            logger.error(f"Error generating audio with Kokoro: {e}")
-            raise
-
-    async def tool_tts_set_speed(self, params: FunctionCallParams, speed_lambda: float):
-        """
-        Set a specific speaking speed of the assistant's voice.
-        This tool should be called only when the user specifies the speed explicitly,
-        such as "speak twice as fast" or "speak half as slow" or "speak 1.5 times as fast".
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-
-        Args:
-            speed_lambda: positive float, the relative change of the speaking speed to the original speed.
-                        E.g., 1.0 for original speed, 1.25 for 25% faster than original speed,
-                        0.8 for 20% slower than original speed.
-
-        """
-        if speed_lambda <= 0:
-            result = {
-                "success": False,
-                "message": f"Speed remains unchanged since the change is not a positive number: {speed_lambda}",
-            }
-            logger.debug(f"Speed remains unchanged since the change is not a positive number: {speed_lambda}")
-        else:
-            self._speed = speed_lambda * self._speed
-            result = {
-                "success": True,
-                "message": f"Speed set to {speed_lambda} of the previous speed",
-            }
-            logger.debug(f"Speed set to {speed_lambda} of the previous speed {self._original_speed}")
-        await params.result_callback(result)
-
-    async def tool_tts_reset_speed(self, params: FunctionCallParams):
-        """
-        Reset the speaking speed to the original speed.
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-        """
-        self._speed = self._original_speed
-        result = {"success": True, "message": "Speaking speed is reset to the original one"}
-        logger.debug(f"Speaking speed is reset to the original speed {self._original_speed}")
-        await params.result_callback(result)
-
-    async def tool_tts_speak_faster(self, params: FunctionCallParams):
-        """
-        Speak faster by increasing the speaking speed 15% faster each time this function is called.
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-        """
-        speed_lambda = 1.15
-        self._speed = speed_lambda * self._speed
-        result = {
-            "success": True,
-            "message": f"Speaking speed is increased to {speed_lambda} of the previous speed",
-        }
-        logger.debug(f"Speed is set to {speed_lambda} of the previous speed, new speed is {self._speed}")
-        await params.result_callback(result)
-
-    async def tool_tts_speak_slower(self, params: FunctionCallParams):
-        """
-        Speak slower by decreasing the speaking speed 15% slower each time this function is called.
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-        """
-        speed_lambda = 0.85
-        self._speed = speed_lambda * self._speed
-        result = {
-            "success": True,
-            "message": f"Speaking speed is decreased to {speed_lambda} of the previous speed",
-        }
-        logger.debug(f"Speed is set to {speed_lambda} of the previous speed, new speed is {self._speed}")
-        await params.result_callback(result)
-
-    async def tool_tts_set_voice(self, params: FunctionCallParams, accent: str, gender: str):
-        """
-        Set the accent and gender of the assistant's voice.
-        This tool should be called only when the user specifies the accent and/or gender explicitly.
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-
-        Args:
-            accent: Accent for the TTS model. Must be one of 'American English', 'British English'
-                    or 'current' for keeping the current accent.
-            gender: gender of the assistant's voice. Must be one of 'male', 'female',
-                    or 'current' for keeping the current gender.
-        """
-        await params.llm.push_frame(LLMTextFrame("Just a moment."))
-
-        lang_code = "a" if accent == "American English" else "b" if accent == "British English" else "current"
-        new_lang_code = self._lang_code
-        new_gender = self._gender
-        if lang_code != 'current':
-            new_lang_code = lang_code
-        if gender != 'current':
-            new_gender = gender
-
-        if new_lang_code == 'a':
-            new_voice = 'af_heart' if new_gender == 'female' else 'am_michael'
-        elif new_lang_code == 'b':
-            new_voice = 'bf_emma' if new_gender == 'female' else 'bm_george'
-        else:
-            await params.result_callback(
-                {
-                    "success": False,
-                    "message": f"Invalid language code: {new_lang_code} or gender: {new_gender}",
-                }
-            )
-            return
-
-        new_model = await asyncio.to_thread(self._setup_model, new_lang_code, new_voice)
-        self._model = new_model
-        self._lang_code = new_lang_code
-        self._gender = new_gender
-        self._voice = new_voice
-        logger.debug(f"Language and voice are set to {new_lang_code} and {new_voice}")
-        await params.result_callback({"success": True, "message": "Voice has been updated."})
-
-    async def tool_tts_reset_voice(self, params: FunctionCallParams):
-        """
-        Reset the accent and voice to the original ones.
-
-        Inform user of the result of this tool call. After calling this tool, continue the previous
-        response if it was unfinished and was interrupted by the user, otherwise start a new response
-        and ask if the user needs help on anything else. Avoid repeating previous responses.
-
-        """
-        await params.llm.push_frame(LLMTextFrame("Of course."))
-
-        new_model = await asyncio.to_thread(self._setup_model, self._original_lang_code, self._original_voice)
-        self._model = new_model
-        self._lang_code = self._original_lang_code
-        self._gender = self._original_gender
-        self._voice = self._original_voice
-        logger.debug(
-            f"Language and voice are reset to the original ones {self._original_lang_code} and {self._original_voice}"
-        )
-        await params.result_callback({"success": True, "message": "Voice has been reset to the original one."})
-
-    def setup_tool_calling(self):
-        """
-        Setup the tool calling mixin by registering all available tools.
-        """
-        self.register_direct_function("tool_tts_reset_speed", self.tool_tts_reset_speed)
-        self.register_direct_function("tool_tts_speak_faster", self.tool_tts_speak_faster)
-        self.register_direct_function("tool_tts_speak_slower", self.tool_tts_speak_slower)
-        self.register_direct_function("tool_tts_set_speed", self.tool_tts_set_speed)
-        self.register_direct_function("tool_tts_set_voice", self.tool_tts_set_voice)
-        self.register_direct_function("tool_tts_reset_voice", self.tool_tts_reset_voice)
-
-    def reset(self):
-        """
-        Reset the voice and speed to the original ones.
-        """
-        self._text_aggregator.reset()
-        self._speed = self._original_speed
-        self._model = self._setup_model(self._original_lang_code, self._original_voice)
-        self._lang_code = self._original_lang_code
-        self._gender = self._original_gender
-        self._voice = self._original_voice
-
-
-class MagpieTTSService(BaseNemoTTSService):
-    """Text-to-Speech service using Magpie TTS model.
-
-    Magpie is a multilingual TTS model with 357 million parameters.
-    More info: https://huggingface.co/nvidia/magpie_tts_multilingual_357m
-
-    Args:
-        model: Model name or path to the Magpie TTS model.
-        language: Language code for the model (default: 'en' for English)
-        speaker: Speaker to use for the model (default: 'Sofia')
-        apply_TN: Whether to apply text normalization (default: False)
-        device: Device to run on (default: 'cuda')
-        **kwargs: Additional arguments passed to BaseNemoTTSService
-    """
-
-    SPEAKER_MAP = {"John": 0, "Sofia": 1, "Aria": 2, "Jason": 3, "Leo": 4}
-
-    def __init__(
-        self,
-        model: str = "nvidia/magpie_tts_multilingual_357m",
-        language: str = "en",
-        speaker: str = "Sofia",
-        apply_TN: bool = False,
-        device: str = "cuda",
-        **kwargs,
-    ):
-        if speaker not in self.SPEAKER_MAP:
-            raise ValueError(f"Invalid speaker: {speaker}, must be one of {list(self.SPEAKER_MAP.keys())}")
-        self._language = language
-        self._current_speaker = speaker
-        self._apply_TN = apply_TN
-        super().__init__(model=model, device=device, **kwargs)
-        self.setup_tool_calling()
-
-    def _setup_model(self):
-        from nemo.collections.tts.models import MagpieTTSModel
-
-        if self._model_name.endswith(".nemo"):
-            model = MagpieTTSModel.restore_from(self._model_name, map_location=torch.device(self._device))
-        else:
-            model = MagpieTTSModel.from_pretrained(self._model_name, map_location=torch.device(self._device))
-        model.eval()
-
-        text = "Warming up the Magpie TTS model, this will help the model to respond faster for later requests."
-        with torch.no_grad():
-            _, _ = model.do_tts(
-                text,
-                language=self._language,
-                apply_TN=self._apply_TN,
-                speaker_index=self.SPEAKER_MAP[self._current_speaker],
-            )
-        torch.cuda.empty_cache()
-        return model
-
-    def _generate_audio(self, text: str) -> Iterator[np.ndarray]:
-        audio, audio_len = self._model.do_tts(
-            text,
-            language=self._language,
-            apply_TN=self._apply_TN,
-            speaker_index=self.SPEAKER_MAP[self._current_speaker],
-        )
-        audio_len = audio_len.view(-1).item()
-        audio = audio.detach().view(-1).cpu().numpy()
-        yield audio[:audio_len]
-
-    def setup_tool_calling(self):
-        """No tools for now for Magpie TTS service."""
-        pass
-
-
-def get_tts_service_from_config(config: DictConfig, audio_logger: Optional[AudioLogger] = None) -> BaseNemoTTSService:
-    """Get the TTS service from the configuration.
-
-    Args:
-        config: The DictConfig object containing the TTS configuration.
-        audio_logger: The audio logger to use for audio logging.
-    Returns:
-        The TTS service.
-    """
-    if isinstance(config, DictConfig):
-        config = OmegaConf.to_container(config, resolve=True)
-    model = config.get("model", None)
-    device = config.get("device", "cuda")
-    if config.get("type", None) != "nemo":
-        raise ValueError(f"Invalid TTS type: {config.get('type', None)}, only 'nemo' is supported")
-    if model is None:
-        raise ValueError("Model is required for Nemo TTS service")
-
-    text_aggregator = SimpleSegmentedTextAggregator(
-        punctuation_marks=config.get("extra_separator", None),
-        ignore_marks=config.get("ignore_strings", None),
-        min_sentence_length=config.get("min_sentence_length", 5),
-        use_legacy_eos_detection=config.get("use_legacy_eos_detection", False),
-    )
-
-    if model == "fastpitch-hifigan":
-        return NeMoFastPitchHiFiGANTTSService(
-            fastpitch_model=config.get("main_model_id", None),
-            hifigan_model=config.get("sub_model_id", None),
-            device=device,
-            text_aggregator=text_aggregator,
-            think_tokens=config.get("think_tokens", None),
-            audio_logger=audio_logger,
-            ignore_strings=config.get("ignore_strings", None),
-        )
-    elif model == "magpie":
-        return MagpieTTSService(
-            model=config.get("main_model_id", None),
-            language=config.get("language", "en"),
-            speaker=config.get("speaker", "Sofia"),
-            apply_TN=config.get("apply_TN", False),
-            device=device,
-            text_aggregator=text_aggregator,
-            think_tokens=config.get("think_tokens", None),
-            audio_logger=audio_logger,
-            ignore_strings=config.get("ignore_strings", None),
-        )
-    elif model == "kokoro":
-        return KokoroTTSService(
-            model=config.get("main_model_id", "hexgrad/Kokoro-82M"),
-            voice=config.get("sub_model_id", "af_heart"),
-            device=device,
-            speed=config.get("speed", 1.0),
-            text_aggregator=text_aggregator,
-            think_tokens=config.get("think_tokens", None),
-            sample_rate=24000,
-            audio_logger=audio_logger,
-            ignore_strings=config.get("ignore_strings", None),
-        )
-    else:
-        raise ValueError(f"Invalid model: {model}, only 'fastpitch-hifigan', 'magpie' and 'kokoro' are supported")

nemo/agents/voice_agent/pipecat/services/nemo/turn_taking.py

@@ -1,441 +0,0 @@
-# Copyright (c) 2025, 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 time
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional, Union
-
-import yaml
-from loguru import logger
-from pipecat.frames.frames import (
-    BotStartedSpeakingFrame,
-    BotStoppedSpeakingFrame,
-    Frame,
-    InterimTranscriptionFrame,
-    StartInterruptionFrame,
-    TranscriptionFrame,
-    UserStartedSpeakingFrame,
-    UserStoppedSpeakingFrame,
-    VADUserStartedSpeakingFrame,
-    VADUserStoppedSpeakingFrame,
-)
-from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
-from pipecat.transcriptions.language import Language
-from pipecat.utils.time import time_now_iso8601
-
-from nemo.agents.voice_agent.pipecat.frames.frames import DiarResultFrame
-from nemo.agents.voice_agent.pipecat.services.nemo.audio_logger import AudioLogger
-
-
-class NeMoTurnTakingService(FrameProcessor):
-    """Service for handling turn-taking in voice conversations with backchannel detection."""
-
-    def __init__(
-        self,
-        backchannel_phrases: Union[str, List[str]] = None,
-        eou_string: str = "<EOU>",
-        eob_string: str = "<EOB>",
-        language: Language = Language.EN_US,
-        use_vad: bool = True,
-        use_diar: bool = False,
-        max_buffer_size: int = 2,
-        bot_stop_delay: float = 0.5,
-        audio_logger: Optional[AudioLogger] = None,
-        can_create_user_frames: bool = True,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.eou_string = eou_string
-        self.eob_string = eob_string
-        self.language = language
-        self.use_vad = use_vad
-        self.use_diar = use_diar
-        self.max_buffer_size = max_buffer_size
-
-        self.backchannel_phrases = self._load_backchannel_phrases(backchannel_phrases)
-        self.backchannel_phrases_nopc = set([self.clean_text(phrase) for phrase in self.backchannel_phrases])
-        self.bot_stop_delay = bot_stop_delay
-        self.can_create_user_frames = can_create_user_frames
-        # internal data
-        self._current_speaker_id = None
-        self._prev_speaker_id = None
-        self._bot_stop_time = None
-        self._bot_speaking = False
-        self._vad_user_speaking = False
-        self._have_sent_user_started_speaking = False
-        self._user_speaking_buffer = ""
-        self._audio_logger = audio_logger
-        if not self.use_vad:
-            # if vad is not used, we assume the user is always speaking
-            self._vad_user_speaking = True
-
-    def _load_backchannel_phrases(self, backchannel_phrases: Optional[Union[str, List[str]]] = None):
-        if not backchannel_phrases:
-            return []
-
-        if isinstance(backchannel_phrases, str) and Path(backchannel_phrases).is_file():
-            logger.info(f"Loading backchannel phrases from file: {backchannel_phrases}")
-            if not Path(backchannel_phrases).exists():
-                raise FileNotFoundError(f"Backchannel phrases file not found: {backchannel_phrases}")
-            with open(backchannel_phrases, "r") as f:
-                backchannel_phrases = yaml.safe_load(f)
-            if not isinstance(backchannel_phrases, list):
-                raise ValueError(f"Backchannel phrases must be a list, got {type(backchannel_phrases)}")
-            logger.info(f"Loaded {len(backchannel_phrases)} backchannel phrases from file: {backchannel_phrases}")
-        elif isinstance(backchannel_phrases, list):
-            logger.info(f"Using backchannel phrases from list: {backchannel_phrases}")
-        else:
-            raise ValueError(f"Invalid backchannel phrases: {backchannel_phrases}")
-        return backchannel_phrases
-
-    def reset(self):
-        """
-        Reset the turn-taking service.
-        """
-        self._current_speaker_id = None
-        self._prev_speaker_id = None
-        self._bot_stop_time = None
-        self._bot_speaking = False
-        self._vad_user_speaking = False
-        self._have_sent_user_started_speaking = False
-        self._user_speaking_buffer = ""
-        if not self.use_vad:
-            # if vad is not used, we assume the user is always speaking
-            self._vad_user_speaking = True
-        logger.debug("TurnTaking service reset complete")
-
-    def clean_text(self, text: str) -> str:
-        """
-        Clean the text so that it can be used for backchannel detection.
-        """
-        if self.language != Language.EN_US:
-            raise ValueError(f"Language {self.language} not supported, currently only English is supported.")
-        for eou_string in [self.eou_string, self.eob_string]:
-            if text.endswith(eou_string):
-                text = text[: -len(eou_string)].strip()
-        text = text.lower()
-        valid_chars = "abcdefghijklmnopqrstuvwxyz'"
-        text = ''.join([c for c in text if c in valid_chars or c.isspace() or c == "'"])
-        return " ".join(text.split()).strip()
-
-    def is_backchannel(self, text: str) -> bool:
-        """
-        Check if the text is a backchannel phrase.
-        """
-        if not self.backchannel_phrases:
-            return False
-        if text.startswith("<speaker_"):
-            # if the text starts with a speaker tag, we remove it
-            text = text[len("<speaker_0>") :]
-        text = self.clean_text(text)
-        return text in self.backchannel_phrases_nopc
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        """Process incoming frames and handle turn-taking logic."""
-        await super().process_frame(frame, direction)
-
-        if self._bot_stop_time is not None:
-            # check if the bot has stopped speaking for more than the delay
-            if time.time() - self._bot_stop_time > self.bot_stop_delay:
-                # set the _bot_speaking flag to False to actually consider the bot as stopped speaking
-                logger.debug(
-                    f"Bot stopped speaking for more than {self.bot_stop_delay} seconds, setting _bot_speaking to False"
-                )
-                self._bot_stop_time = None
-                self._bot_speaking = False
-
-        if isinstance(frame, (TranscriptionFrame, InterimTranscriptionFrame)):
-            await self._handle_transcription(frame, direction)
-        elif isinstance(frame, VADUserStartedSpeakingFrame):
-            await self._handle_vad_user_started_speaking(frame, direction)
-        elif isinstance(frame, VADUserStoppedSpeakingFrame):
-            await self._handle_vad_user_stopped_speaking(frame, direction)
-        elif isinstance(frame, BotStartedSpeakingFrame):
-            logger.debug("BotStartedSpeakingFrame received")
-            self._bot_speaking = True
-            # Capture the actual start time when audio starts playing
-            # This is more accurate than capturing during TTS generation
-            if self._audio_logger:
-                self._audio_logger.set_agent_turn_start_time()
-        elif isinstance(frame, BotStoppedSpeakingFrame):
-            logger.debug("BotStoppedSpeakingFrame received")
-            self._bot_stop_time = time.time()
-            if self.bot_stop_delay is None or self.bot_stop_delay <= 0:
-                # only set the flag if the delay is not set or is 0
-                self._bot_speaking = False
-                logger.debug("Setting _bot_speaking to False")
-        elif isinstance(frame, DiarResultFrame):
-            logger.debug("DiarResultFrame received")
-            await self._handle_diar_result(frame, direction)
-        else:
-            await self.push_frame(frame, direction)
-
-    async def _handle_backchannel_text(self, text: str):
-        # ignore the backchannel string while bot is speaking
-        # push the backchannel string upstream, not downstream
-        await self.push_frame(
-            TranscriptionFrame(
-                text=f"({text})",
-                user_id="",
-                timestamp=time_now_iso8601(),
-                language=self.language if self.language else Language.EN_US,
-                result={"text": f"Backchannel detected: {text}"},
-            ),
-            direction=FrameDirection.UPSTREAM,
-        )
-
-    async def _handle_transcription(
-        self, frame: TranscriptionFrame | InterimTranscriptionFrame, direction: FrameDirection
-    ):
-        text_segment = frame.text
-        if self._vad_user_speaking:
-            self._user_speaking_buffer += text_segment
-            has_eou = self._user_speaking_buffer.endswith(self.eou_string)
-            has_eob = self._user_speaking_buffer.endswith(self.eob_string)
-            if has_eou:
-                # EOU detected, user is done speaking - push completed text and interrupt bot
-                logger.debug(f"<EOU> Detected: `{self._user_speaking_buffer}`")
-                completed_text = self._user_speaking_buffer[: -len(self.eou_string)].strip()
-                if self._bot_speaking and self.is_backchannel(completed_text):
-                    logger.debug(f"<EOU> detected for a backchannel phrase while bot is speaking: `{completed_text}`")
-                    await self._handle_backchannel_text(completed_text)
-                    if self._audio_logger:
-                        if self._audio_logger.staged_metadata is None:
-                            self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
-                        else:
-                            self._audio_logger.staged_metadata["is_backchannel"] = True
-
-                else:
-                    await self._handle_completed_text(completed_text, direction)
-                    await self._handle_user_interruption(UserStoppedSpeakingFrame())
-                self._user_speaking_buffer = ""
-                self._have_sent_user_started_speaking = False  # user is done speaking, so we reset the flag
-            elif has_eob and self._bot_speaking:
-                logger.debug(f"<EOB> detected while bot is speaking: `{self._user_speaking_buffer}`")
-                await self._handle_backchannel_text(str(self._user_speaking_buffer))
-                if self._audio_logger:
-                    if self._audio_logger.staged_metadata is None:
-                        self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
-                    else:
-                        self._audio_logger.staged_metadata["is_backchannel"] = True
-                self._user_speaking_buffer = ""
-                self._have_sent_user_started_speaking = False  # user is done speaking, so we reset the flag
-            else:
-                # if bot is not speaking, the backchannel string is not considered a backchannel phrase
-                # user is still speaking, so we append the text segment to the buffer
-                logger.debug(f"User is speaking: `{self._user_speaking_buffer}`")
-                if has_eob:
-                    logger.debug(
-                        f"{self.eob_string} detected but ignored (bot NOT speaking): "
-                        f"`{self._user_speaking_buffer}`"
-                    )
-                    self._user_speaking_buffer = self._user_speaking_buffer[: -len(self.eob_string)].strip()
-                # assume the last word is not completed
-                completed_words = self._user_speaking_buffer.strip().split()[:-1]
-                if len(completed_words) >= self.max_buffer_size:
-                    completed_text = " ".join(completed_words)
-                    await self._handle_completed_text(completed_text, direction, is_final=False)
-
-        else:
-            # if vad is not detecting user speaking
-            logger.debug(
-                f"VAD is not detecting user speaking, but still received text segment from STT: `{text_segment}`"
-            )
-            is_backchannel = self.is_backchannel(text_segment)
-            if text_segment.endswith(self.eob_string):
-                is_backchannel = True
-                logger.debug(f"Dropping EOB token: `{text_segment}`")
-                text_segment = text_segment[: -len(self.eob_string)].strip()
-            elif text_segment.endswith(self.eou_string):
-                logger.debug(f"Dropping EOU token: `{text_segment}`")
-                text_segment = text_segment[: -len(self.eou_string)].strip()
-
-            if not text_segment.strip():
-                return
-            if is_backchannel and self._bot_speaking:
-                logger.debug(f"Backchannel detected while bot is speaking: `{text_segment}`")
-                # push the backchannel string upstream, not downstream
-                curr_text = str(self._user_speaking_buffer + text_segment)
-                self._user_speaking_buffer = ""
-                if self._audio_logger:
-                    if self._audio_logger.staged_metadata is None:
-                        self._audio_logger.staged_metadata = {"is_backchannel": True, "start_time": datetime.now()}
-                    else:
-                        self._audio_logger.staged_metadata["is_backchannel"] = True
-                await self.push_frame(
-                    TranscriptionFrame(
-                        text=f"({curr_text})",
-                        user_id="",
-                        timestamp=time_now_iso8601(),
-                        language=self.language if self.language else Language.EN_US,
-                        result={"text": f"Backchannel detected: {self._user_speaking_buffer+text_segment}"},
-                    ),
-                    direction=FrameDirection.UPSTREAM,
-                )
-
-            else:
-                # if the text segment is not empty and have non-space characters, we append it to the buffer
-                self._user_speaking_buffer += text_segment
-                if self.is_backchannel(self._user_speaking_buffer):
-                    logger.debug(f"Backchannel detected: `{self._user_speaking_buffer}`")
-                    self._user_speaking_buffer = ""
-                    self._have_sent_user_started_speaking = False
-                    return
-                logger.debug(f"Appending text segment to user speaking buffer: `{self._user_speaking_buffer}`")
-
-    async def _handle_completed_text(self, completed_text: str, direction: FrameDirection, is_final: bool = True):
-        if not self._have_sent_user_started_speaking:
-            # if we haven't sent the user started speaking frame, we send it now
-            # so that the bot can be interrupted and be ready to respond to the new user turn
-            await self._handle_user_interruption(UserStartedSpeakingFrame())
-            self._have_sent_user_started_speaking = True
-
-        completed_text = completed_text.strip()
-        completed_text = completed_text.replace(self.eou_string, "").replace(self.eob_string, "")
-
-        if self.use_diar and not completed_text.startswith("<speaker_") and self._prev_speaker_id is not None:
-            # Add the previous speaker tag to the beginning of the text
-            completed_text = f"<speaker_{self._prev_speaker_id}> {completed_text}"
-
-        frame_type = TranscriptionFrame if is_final else InterimTranscriptionFrame
-        text_frame = frame_type(
-            text=completed_text,
-            user_id="",  # No speaker ID in this implementation
-            timestamp=time_now_iso8601(),
-            language=self.language if self.language else Language.EN_US,
-            result={"text": completed_text},
-        )
-        logger.debug(f"Pushing text frame: {text_frame}")
-        await self.push_frame(text_frame, direction)
-
-    def _contains_only_speaker_tags(self, text: str) -> bool:
-        """
-        Check if the text contains only speaker tags.
-        """
-        return text.strip().startswith("<speaker_") and text.strip().endswith(">")
-
-    async def _handle_vad_user_started_speaking(self, frame: VADUserStartedSpeakingFrame, direction: FrameDirection):
-        """
-        Handle the user started speaking frame.
-
-        If there are no backchannel phrases and we haven't sent the user started speaking frame, we send it now
-        so that the bot can be interrupted and be ready to respond to the new user turn
-        """
-        self._vad_user_speaking = True
-        logger.debug("NeMoTurnTakingService: VADUserStartedSpeakingFrame")
-        await self.push_frame(frame, direction)
-        if not self.backchannel_phrases and not self._have_sent_user_started_speaking:
-            await self._handle_user_interruption(UserStartedSpeakingFrame())
-            self._have_sent_user_started_speaking = True
-
-    async def _handle_vad_user_stopped_speaking(self, frame: VADUserStoppedSpeakingFrame, direction: FrameDirection):
-        """
-        Handle the user stopped speaking frame.
-
-        If the buffer is not empty:
-            - If bot is not speaking: push completed text regardless of backchannel
-            - If bot is speaking: ignore backchannel strings
-        If the buffer is empty, do nothing.
-        """
-        if self.use_vad:
-            self._vad_user_speaking = False
-        logger.debug("NeMoTurnTakingService: VADUserStoppedSpeakingFrame")
-        await self.push_frame(frame, direction)
-
-        # if user buffer only contains speaker tags, we don't push the completed text frame
-        if self._contains_only_speaker_tags(self._user_speaking_buffer):
-            logger.debug(f"User buffer only contains speaker tags: `{self._user_speaking_buffer}`, ignoring")
-            return
-
-        is_backchannel = self.is_backchannel(self._user_speaking_buffer)
-        if not self._user_speaking_buffer:
-            return
-        if not self._bot_speaking or not is_backchannel:
-            logger.debug(f"Bot talking: {self._bot_speaking}, backchannel: {is_backchannel}")
-            logger.debug(f"Pushing completed text frame for VAD user stopped speaking: {self._user_speaking_buffer}")
-            await self._handle_completed_text(self._user_speaking_buffer, direction)
-            self._user_speaking_buffer = ""
-            if self._have_sent_user_started_speaking:
-                await self._handle_user_interruption(UserStoppedSpeakingFrame())
-                self._have_sent_user_started_speaking = False
-        elif is_backchannel:
-            logger.debug(f"Backchannel detected: `{self._user_speaking_buffer}`")
-            if self._audio_logger:
-                self._audio_logger.save_user_audio(is_backchannel=True)
-                logger.debug(
-                    f"[TurnTakingService] Saved backchannel audio (VAD stopped): {self._user_speaking_buffer}"
-                )
-
-            await self.push_frame(
-                TranscriptionFrame(
-                    text=f"({self._user_speaking_buffer})",
-                    user_id="",
-                    timestamp=time_now_iso8601(),
-                    language=self.language if self.language else Language.EN_US,
-                    result={"text": f"Backchannel detected: {self._user_speaking_buffer}"},
-                ),
-                direction=FrameDirection.UPSTREAM,
-            )
-            self._user_speaking_buffer = ""
-            self._have_sent_user_started_speaking = False
-
-    async def _handle_user_interruption(self, frame: Frame):
-        # Adapted from BaseInputTransport._handle_user_interruption
-        if isinstance(frame, UserStartedSpeakingFrame):
-            logger.debug("User started speaking")
-            if self.can_create_user_frames:
-                logger.debug("Pushing UserStartedSpeakingFrame and StartInterruptionFrame")
-                await self.push_frame(frame)
-                await self.push_frame(StartInterruptionFrame(), direction=FrameDirection.DOWNSTREAM)
-            else:
-                logger.debug(
-                    "Skipping UserStartedSpeakingFrame and StartInterruptionFrame because can_create_user_frames is False"
-                )
-            # Record cutoff time for agent audio when TTS is interrupted
-            if self._audio_logger and self._bot_speaking:
-                self._audio_logger.set_agent_cutoff_time()
-            # Increment turn index when user starts speaking (only if speaker changed)
-            if self._audio_logger:
-                self._audio_logger.increment_turn_index(speaker="user")
-        elif isinstance(frame, UserStoppedSpeakingFrame):
-            logger.debug("User stopped speaking")
-            if self.can_create_user_frames:
-                logger.debug("Pushing UserStoppedSpeakingFrame")
-                await self.push_frame(frame)
-            else:
-                logger.debug("Skipping UserStoppedSpeakingFrame because can_create_user_frames is False")
-        else:
-            logger.debug(f"Unknown frame type for _handle_user_interruption: {type(frame)}")
-
-    async def _handle_diar_result(self, frame: DiarResultFrame, direction: FrameDirection):
-        if not self.use_diar:
-            logger.debug("Diarization is disabled, skipping")
-            return
-
-        new_speaker_id = frame.diar_result  # speaker id of the dominant speaker
-
-        # logger.debug(f"Dominant speaker ID: {dominant_speaker_id}")
-        self._prev_speaker_id = self._current_speaker_id
-        last_speaker_id = self._current_speaker_id
-
-        if not self._user_speaking_buffer.startswith("<speaker_"):
-            # add speaker tag <speaker_{speaker_id}> to the beginning of the current utterance
-            self._user_speaking_buffer = f"<speaker_{new_speaker_id}> {self._user_speaking_buffer}"
-        elif last_speaker_id != new_speaker_id:
-            # change the speaker tag to the dominant speaker id
-            self._user_speaking_buffer = self._user_speaking_buffer[len("<speaker_0>") :]
-            self._user_speaking_buffer = f"<speaker_{new_speaker_id}> {self._user_speaking_buffer}"
-        logger.debug(f"Speaker changed from {last_speaker_id} to {new_speaker_id}")
-        self._current_speaker_id = new_speaker_id

nemo/agents/voice_agent/pipecat/services/nemo/utils.py

@@ -1,197 +0,0 @@
-# Copyright (c) 2025, 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.
-# NOTE: This file will be deprecated in the future, as the new inference pipeline will replace it.
-
-import math
-
-import numpy as np
-import torch
-from omegaconf import DictConfig
-
-import nemo.collections.asr as nemo_asr
-
-LOG_MEL_ZERO = -16.635
-
-
-class AudioBufferer:
-    def __init__(self, sample_rate: int, buffer_size_in_secs: float):
-        self.buffer_size = int(buffer_size_in_secs * sample_rate)
-        self.sample_buffer = torch.zeros(self.buffer_size, dtype=torch.float32)
-
-    def reset(self) -> None:
-        """
-        Reset the buffer to zero
-        """
-        self.sample_buffer.zero_()
-
-    def update(self, audio: np.ndarray) -> None:
-        """
-        Update the buffer with the new frame
-        Args:
-            frame (Frame): frame to update the buffer with
-        """
-        if not isinstance(audio, torch.Tensor):
-            audio = torch.from_numpy(audio)
-
-        audio_size = audio.shape[0]
-        if audio_size > self.buffer_size:
-            raise ValueError(f"Frame size ({audio_size}) exceeds buffer size ({self.buffer_size})")
-
-        shift = audio_size
-        self.sample_buffer[:-shift] = self.sample_buffer[shift:].clone()
-        self.sample_buffer[-shift:] = audio.clone()
-
-    def get_buffer(self) -> torch.Tensor:
-        """
-        Get the current buffer
-        Returns:
-            torch.Tensor: current state of the buffer
-        """
-        return self.sample_buffer.clone()
-
-    def is_buffer_empty(self) -> bool:
-        """
-        Check if the buffer is empty
-        Returns:
-            bool: True if the buffer is empty, False otherwise
-        """
-        return self.sample_buffer.sum() == 0
-
-
-class CacheFeatureBufferer:
-    def __init__(
-        self,
-        sample_rate: int,
-        buffer_size_in_secs: float,
-        chunk_size_in_secs: float,
-        preprocessor_cfg: DictConfig,
-        device: torch.device,
-        fill_value: float = LOG_MEL_ZERO,
-    ):
-
-        if buffer_size_in_secs < chunk_size_in_secs:
-            raise ValueError(
-                f"Buffer size ({buffer_size_in_secs}s) should be no less than chunk size ({chunk_size_in_secs}s)"
-            )
-
-        self.sample_rate = sample_rate
-        self.buffer_size_in_secs = buffer_size_in_secs
-        self.chunk_size_in_secs = chunk_size_in_secs
-        self.device = device
-
-        if hasattr(preprocessor_cfg, 'log') and preprocessor_cfg.log:
-            self.ZERO_LEVEL_SPEC_DB_VAL = LOG_MEL_ZERO  # Log-Mel spectrogram value for zero signals
-        else:
-            self.ZERO_LEVEL_SPEC_DB_VAL = fill_value
-
-        self.n_feat = preprocessor_cfg.features
-        self.timestep_duration = preprocessor_cfg.window_stride
-        self.n_chunk_look_back = int(self.timestep_duration * self.sample_rate)
-        self.chunk_size = int(self.chunk_size_in_secs * self.sample_rate)
-        self.sample_buffer = AudioBufferer(sample_rate, buffer_size_in_secs)
-
-        self.feature_buffer_len = int(buffer_size_in_secs / self.timestep_duration)
-        self.feature_chunk_len = int(chunk_size_in_secs / self.timestep_duration)
-        self.feature_buffer = torch.full(
-            [self.n_feat, self.feature_buffer_len],
-            self.ZERO_LEVEL_SPEC_DB_VAL,
-            dtype=torch.float32,
-            device=self.device,
-        )
-
-        self.preprocessor = nemo_asr.models.ASRModel.from_config_dict(preprocessor_cfg)
-        self.preprocessor.to(self.device)
-
-    def is_buffer_empty(self) -> bool:
-        """
-        Check if the buffer is empty
-        Returns:
-            bool: True if the buffer is empty, False otherwise
-        """
-        return self.sample_buffer.is_buffer_empty()
-
-    def reset(self) -> None:
-        """
-        Reset the buffer to zero
-        """
-        self.sample_buffer.reset()
-        self.feature_buffer.fill_(self.ZERO_LEVEL_SPEC_DB_VAL)
-
-    def _update_feature_buffer(self, feat_chunk: torch.Tensor) -> None:
-        """
-        Add an extracted feature to `feature_buffer`
-        """
-        self.feature_buffer[:, : -self.feature_chunk_len] = self.feature_buffer[:, self.feature_chunk_len :].clone()
-        self.feature_buffer[:, -self.feature_chunk_len :] = feat_chunk.clone()
-
-    def preprocess(self, audio_signal: torch.Tensor) -> torch.Tensor:
-        """
-        Preprocess the audio signal using the preprocessor
-        Args:
-            audio_signal (torch.Tensor): audio signal
-        Returns:
-            torch.Tensor: preprocessed features
-        """
-        audio_signal = audio_signal.unsqueeze_(0).to(self.device)
-        audio_signal_len = torch.tensor([audio_signal.shape[1]], device=self.device)
-        features, _ = self.preprocessor(
-            input_signal=audio_signal,
-            length=audio_signal_len,
-        )
-        features = features.squeeze()
-        return features
-
-    def update(self, audio: np.ndarray) -> None:
-        """
-        Update the sample anf feature buffers with the new frame
-        Args:
-            frame (Frame): frame to update the buffer with
-        """
-
-        # Update the sample buffer with the new frame
-        self.sample_buffer.update(audio)
-
-        if math.isclose(self.buffer_size_in_secs, self.chunk_size_in_secs):
-            # If the buffer size is equal to the chunk size, just take the whole buffer
-            samples = self.sample_buffer.sample_buffer.clone()
-        else:
-            # Add look_back to have context for the first feature
-            samples = self.sample_buffer.sample_buffer[-(self.n_chunk_look_back + self.chunk_size) :]
-
-        # Get the mel spectrogram
-        features = self.preprocess(samples)
-
-        # If the features are longer than supposed to be, drop the last frames
-        # Drop the last diff frames because they might be incomplete
-        if (diff := features.shape[1] - self.feature_chunk_len - 1) > 0:
-            features = features[:, :-diff]
-
-        # Update the feature buffer with the new features
-        self._update_feature_buffer(features[:, -self.feature_chunk_len :])
-
-    def get_buffer(self) -> torch.Tensor:
-        """
-        Get the current sample buffer
-        Returns:
-            torch.Tensor: current state of the buffer
-        """
-        return self.sample_buffer.get_buffer()
-
-    def get_feature_buffer(self) -> torch.Tensor:
-        """
-        Get the current feature buffer
-        Returns:
-            torch.Tensor: current state of the feature buffer
-        """
-        return self.feature_buffer.clone()

nemo/agents/voice_agent/pipecat/transports/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/transports/base_input.py

@@ -1,58 +0,0 @@
-# Copyright (c) 2025, 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 loguru import logger
-from pipecat.audio.vad.vad_analyzer import VADState
-from pipecat.frames.frames import (
-    InputAudioRawFrame,
-    UserStartedSpeakingFrame,
-    UserStoppedSpeakingFrame,
-    VADUserStartedSpeakingFrame,
-    VADUserStoppedSpeakingFrame,
-)
-from pipecat.transports.base_input import BaseInputTransport as _BaseInputTransport
-
-
-class BaseInputTransport(_BaseInputTransport):
-    async def _handle_vad(self, audio_frame: InputAudioRawFrame, vad_state: VADState):
-        """Handle Voice Activity Detection results and generate appropriate frames."""
-        new_vad_state = await self._vad_analyze(audio_frame)
-        if new_vad_state != vad_state and new_vad_state != VADState.STARTING and new_vad_state != VADState.STOPPING:
-            frame = None
-            # If the turn analyser is enabled, this will prevent:
-            # - Creating the UserStoppedSpeakingFrame
-            # - Creating the UserStartedSpeakingFrame multiple times
-            can_create_user_frames = (
-                self._params.turn_analyzer is None or not self._params.turn_analyzer.speech_triggered
-            ) and self._params.can_create_user_frames
-
-            if new_vad_state == VADState.SPEAKING:
-                await self.push_frame(VADUserStartedSpeakingFrame())
-                if can_create_user_frames:
-                    frame = UserStartedSpeakingFrame()
-                else:
-                    logger.debug("base_input: VAD state changed to SPEAKING but can_create_user_frames is False")
-            elif new_vad_state == VADState.QUIET:
-                await self.push_frame(VADUserStoppedSpeakingFrame())
-                if can_create_user_frames:
-                    frame = UserStoppedSpeakingFrame()
-                else:
-                    logger.debug("base_input: VAD state changed to QUIET but can_create_user_frames is False")
-
-            if frame:
-                await self._handle_user_interruption(frame)
-
-            vad_state = new_vad_state
-        return vad_state

nemo/agents/voice_agent/pipecat/transports/base_transport.py

@@ -1,20 +0,0 @@
-# Copyright (c) 2025, 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 pipecat.transports.base_transport import TransportParams as _TransportParams
-
-
-class TransportParams(_TransportParams):
-    can_create_user_frames: bool = True

nemo/agents/voice_agent/pipecat/transports/network/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/transports/network/websocket_server.py

@@ -1,304 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-from typing import Optional
-
-from loguru import logger
-from pipecat.frames.frames import CancelFrame, EndFrame, InputAudioRawFrame, StartFrame
-from pipecat.serializers.base_serializer import FrameSerializer
-from pipecat.transports.base_transport import BaseTransport
-from pipecat.transports.network.websocket_server import (
-    WebsocketServerCallbacks,
-    WebsocketServerOutputTransport,
-    WebsocketServerParams,
-)
-
-from nemo.agents.voice_agent.pipecat.transports.base_input import BaseInputTransport
-from nemo.agents.voice_agent.pipecat.transports.base_transport import TransportParams
-
-try:
-    import websockets
-except ModuleNotFoundError as e:
-    logger.error(f"Exception: {e}")
-    logger.error("In order to use websockets, you need to `pip install pipecat-ai[websocket]`.")
-    raise Exception(f"Missing module: {e}")
-
-
-class WebsocketServerParams(TransportParams):
-    """Configuration parameters for WebSocket server transport.
-
-    Parameters:
-        add_wav_header: Whether to add WAV headers to audio frames.
-        serializer: Frame serializer for message encoding/decoding.
-        session_timeout: Timeout in seconds for client sessions.
-    """
-
-    add_wav_header: bool = False
-    serializer: Optional[FrameSerializer] = None
-    session_timeout: Optional[int] = None
-
-
-class WebsocketServerInputTransport(BaseInputTransport):
-    """WebSocket server input transport for receiving client data.
-
-    Handles incoming WebSocket connections, message processing, and client
-    session management including timeout monitoring and connection lifecycle.
-    """
-
-    def __init__(
-        self,
-        transport: BaseTransport,
-        host: str,
-        port: int,
-        params: WebsocketServerParams,
-        callbacks: WebsocketServerCallbacks,
-        **kwargs,
-    ):
-        """Initialize the WebSocket server input transport.
-
-        Args:
-            transport: The parent transport instance.
-            host: Host address to bind the WebSocket server to.
-            port: Port number to bind the WebSocket server to.
-            params: WebSocket server configuration parameters.
-            callbacks: Callback functions for WebSocket events.
-            **kwargs: Additional arguments passed to parent class.
-        """
-        super().__init__(params, **kwargs)
-
-        self._transport = transport
-        self._host = host
-        self._port = port
-        self._params = params
-        self._callbacks = callbacks
-
-        self._websocket: Optional[websockets.WebSocketServerProtocol] = None
-
-        self._server_task = None
-
-        # This task will monitor the websocket connection periodically.
-        self._monitor_task = None
-
-        self._stop_server_event = asyncio.Event()
-
-        # Whether we have seen a StartFrame already.
-        self._initialized = False
-
-    async def start(self, frame: StartFrame):
-        """Start the WebSocket server and initialize components.
-
-        Args:
-            frame: The start frame containing initialization parameters.
-        """
-        await super().start(frame)
-
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-        if self._params.serializer:
-            await self._params.serializer.setup(frame)
-        if not self._server_task:
-            self._server_task = self.create_task(self._server_task_handler())
-        await self.set_transport_ready(frame)
-
-    async def stop(self, frame: EndFrame):
-        """Stop the WebSocket server and cleanup resources.
-
-        Args:
-            frame: The end frame signaling transport shutdown.
-        """
-        await super().stop(frame)
-        self._stop_server_event.set()
-        if self._monitor_task:
-            await self.cancel_task(self._monitor_task)
-            self._monitor_task = None
-        if self._server_task:
-            await self.wait_for_task(self._server_task)
-            self._server_task = None
-
-    async def cancel(self, frame: CancelFrame):
-        """Cancel the WebSocket server and stop all processing.
-
-        Args:
-            frame: The cancel frame signaling immediate cancellation.
-        """
-        await super().cancel(frame)
-        if self._monitor_task:
-            await self.cancel_task(self._monitor_task)
-            self._monitor_task = None
-        if self._server_task:
-            await self.cancel_task(self._server_task)
-            self._server_task = None
-
-    async def cleanup(self):
-        """Cleanup resources and parent transport."""
-        await super().cleanup()
-        await self._transport.cleanup()
-
-    async def _server_task_handler(self):
-        """Handle WebSocket server startup and client connections."""
-        logger.info(f"Starting websocket server on {self._host}:{self._port}")
-        async with websockets.serve(self._client_handler, self._host, self._port) as server:
-            await self._callbacks.on_websocket_ready()
-            await self._stop_server_event.wait()
-
-    async def _client_handler(self, websocket: websockets.WebSocketServerProtocol, path: Optional[str] = None):
-        """Handle individual client connections and message processing."""
-        logger.info(f"New client connection from {websocket.remote_address}")
-        if self._websocket:
-            await self._websocket.close()
-            logger.warning("Only one client connected, using new connection")
-
-        self._websocket = websocket
-
-        # Notify
-        await self._callbacks.on_client_connected(websocket)
-
-        # Create a task to monitor the websocket connection
-        if not self._monitor_task and self._params.session_timeout:
-            self._monitor_task = self.create_task(self._monitor_websocket(websocket, self._params.session_timeout))
-
-        # Handle incoming messages
-        try:
-            async for message in websocket:
-                if not self._params.serializer:
-                    continue
-
-                frame = await self._params.serializer.deserialize(message)
-
-                if not frame:
-                    continue
-
-                if isinstance(frame, InputAudioRawFrame):
-                    await self.push_audio_frame(frame)
-                else:
-                    await self.push_frame(frame)
-        except Exception as e:
-            logger.error(f"{self} exception receiving data: {e.__class__.__name__} ({e})")
-
-        # Notify disconnection
-        await self._callbacks.on_client_disconnected(websocket)
-
-        await self._websocket.close()
-        self._websocket = None
-
-        logger.info(f"Client {websocket.remote_address} disconnected")
-
-    async def _monitor_websocket(self, websocket: websockets.WebSocketServerProtocol, session_timeout: int):
-        """Monitor WebSocket connection for session timeout."""
-        try:
-            await asyncio.sleep(session_timeout)
-            if not websocket.closed:
-                await self._callbacks.on_session_timeout(websocket)
-        except asyncio.CancelledError:
-            logger.info(f"Monitoring task cancelled for: {websocket.remote_address}")
-            raise
-
-
-class WebsocketServerTransport(BaseTransport):
-    """WebSocket server transport for bidirectional real-time communication.
-
-    Provides a complete WebSocket server implementation with separate input and
-    output transports, client connection management, and event handling for
-    real-time audio and data streaming applications.
-    """
-
-    def __init__(
-        self,
-        params: WebsocketServerParams,
-        host: str = "localhost",
-        port: int = 8765,
-        input_name: Optional[str] = None,
-        output_name: Optional[str] = None,
-    ):
-        """Initialize the WebSocket server transport.
-
-        Args:
-            params: WebSocket server configuration parameters.
-            host: Host address to bind the server to. Defaults to "localhost".
-            port: Port number to bind the server to. Defaults to 8765.
-            input_name: Optional name for the input processor.
-            output_name: Optional name for the output processor.
-        """
-        super().__init__(input_name=input_name, output_name=output_name)
-        self._host = host
-        self._port = port
-        self._params = params
-
-        self._callbacks = WebsocketServerCallbacks(
-            on_client_connected=self._on_client_connected,
-            on_client_disconnected=self._on_client_disconnected,
-            on_session_timeout=self._on_session_timeout,
-            on_websocket_ready=self._on_websocket_ready,
-        )
-        self._input: Optional[WebsocketServerInputTransport] = None
-        self._output: Optional[WebsocketServerOutputTransport] = None
-        self._websocket: Optional[websockets.WebSocketServerProtocol] = None
-
-        # Register supported handlers. The user will only be able to register
-        # these handlers.
-        self._register_event_handler("on_client_connected")
-        self._register_event_handler("on_client_disconnected")
-        self._register_event_handler("on_session_timeout")
-        self._register_event_handler("on_websocket_ready")
-
-    def input(self) -> WebsocketServerInputTransport:
-        """Get the input transport for receiving client data.
-
-        Returns:
-            The WebSocket server input transport instance.
-        """
-        if not self._input:
-            self._input = WebsocketServerInputTransport(
-                self, self._host, self._port, self._params, self._callbacks, name=self._input_name
-            )
-        return self._input
-
-    def output(self) -> WebsocketServerOutputTransport:
-        """Get the output transport for sending data to clients.
-
-        Returns:
-            The WebSocket server output transport instance.
-        """
-        if not self._output:
-            self._output = WebsocketServerOutputTransport(self, self._params, name=self._output_name)
-        return self._output
-
-    async def _on_client_connected(self, websocket):
-        """Handle client connection events."""
-        if self._output:
-            await self._output.set_client_connection(websocket)
-            await self._call_event_handler("on_client_connected", websocket)
-        else:
-            logger.error("A WebsocketServerTransport output is missing in the pipeline")
-
-    async def _on_client_disconnected(self, websocket):
-        """Handle client disconnection events."""
-        if self._output:
-            await self._output.set_client_connection(None)
-            await self._call_event_handler("on_client_disconnected", websocket)
-        else:
-            logger.error("A WebsocketServerTransport output is missing in the pipeline")
-
-    async def _on_session_timeout(self, websocket):
-        """Handle client session timeout events."""
-        await self._call_event_handler("on_session_timeout", websocket)
-
-    async def _on_websocket_ready(self):
-        """Handle WebSocket server ready events."""
-        await self._call_event_handler("on_websocket_ready")

nemo/agents/voice_agent/pipecat/utils/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/utils/text/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/pipecat/utils/text/simple_text_aggregator.py

@@ -1,238 +0,0 @@
-# Copyright (c) 2025, 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 re
-from typing import AsyncIterator, Optional
-
-from loguru import logger
-from pipecat.utils.string import match_endofsentence
-from pipecat.utils.text.base_text_aggregator import Aggregation, AggregationType
-from pipecat.utils.text.simple_text_aggregator import SimpleTextAggregator
-
-
-def has_partial_decimal(text: str) -> bool:
-    """Check if the text ends with a partial decimal.
-
-    Returns True if the text ends with a number that looks like it could
-    be a partial decimal (e.g., "3.", "3.14", "($3.14)"), but NOT if it's
-    clearly a complete sentence (e.g., "It costs $3.14.") or a bullet point
-    (e.g., "1. Alpha; 2.").
-    """
-
-    # Check for bullet point pattern: ends with 1-3 digits followed by period
-    # Examples: "1.", "12.", "123.", or "text; 2."
-    # Bullet points are typically small numbers (1-999) at the end
-    bullet_match = re.search(r'(?:^|[\s;,]|[^\d])(\d{1,3})\.$', text)
-    if bullet_match:
-        # It's likely a bullet point, not a partial decimal
-        return False
-
-    # Pattern to find decimal numbers near the end, allowing for trailing
-    # non-word characters like ), ], ", ', etc.
-    # Match: digit(s) + period + optional digit(s) + optional trailing non-word chars
-    match = re.search(r'\d+\.(?:\d+)?([^\w\s]*)$', text)
-
-    if not match:
-        return False
-
-    trailing = match.group(1)  # e.g., ")" or "" or "."
-
-    # If trailing contains a period, it's sentence-ending punctuation
-    # e.g., "3.14." means complete sentence
-    if '.' in trailing:
-        return False
-
-    # Otherwise, it's a partial decimal (either incomplete like "3."
-    # or complete number but sentence not finished like "($3.14)")
-    return True
-
-
-def find_last_period_index(text: str) -> int:
-    """
-    Find the last occurrence of a period in the text,
-    but return -1 if the text doesn't seem to be a complete sentence.
-    """
-    num_periods = text.count(".")
-    if num_periods == 0:
-        return -1
-
-    if num_periods == 1:
-        if has_partial_decimal(text):
-            # if the only period in the text is part of a number, return -1
-            return -1
-        # Check if the only period is a bullet point (e.g., "1. Alpha" or incomplete "1.")
-        if re.search(r'(?:^|[\s;,]|[^\d])(\d{1,3})\.(?:\s+\w|\s*$)', text):
-            # The period is after a bullet point number, either:
-            # - followed by content (e.g., "1. Alpha")
-            # - or at the end with optional whitespace (e.g., "1." or "1. ")
-            return -1
-
-        # Check if any of the abbreviations "e.", "i." "g.", "etc." are present in the text
-        if re.search(r'\b(e\.|i\.|g\.)\b', text):
-            # The period is after a character/word that is likely to be a abbreviation, return -1
-            return -1
-
-    # otherwise, check the last occurrence of a period
-    idx = text.rfind(".")
-    if idx <= 0:
-        return idx
-    if text[idx - 1].isdigit():
-        # if the period is after a digit, it's likely a partial decimal, return -1
-        return -1
-    elif text[idx - 1].isupper():
-        # if the period is after a capital letter (e.g., "Washington, D.C."), it's likely a abbreviation, return -1
-        return -1
-    elif idx > 1 and text[idx - 2 : idx + 1].lower() in ["a.m.", "p.m."]:
-        # if the period is after a.m. or p.m., it's likely a time, return -1
-        return -1
-    elif idx > 2 and text[idx - 3 : idx + 1] in ["e.g.", "i.e.", "etc."]:
-        # The period is after a character/word that is likely to be a abbreviation, return -1
-        return -1
-    elif idx >= 2 and text[idx - 2 : idx + 1].lower() in ["st.", "mr.", "mrs.", "ms.", "dr."]:
-        # if the period is after a character/word that is likely to be a abbreviation, return -1
-        return -1
-
-    # the text seems to have a complete sentence, return the index of the last period
-    return idx
-
-
-def find_last_comma_index(text: str, min_residual_length: int = 5) -> int:
-    """
-    Find the last occurrence of a valid comma in the text,
-    ignoring the commas in the numbers (e.g., "1,234,567").
-    If the leftover text after the comma is too short, it may be an abbreviation, return -1.
-
-    Args:
-        text: The text to find the last occurrence of a valid comma.
-        min_residual_length: The minimum length of the leftover text after the rightmost comma
-                             to be considered as a valid sentence (e.g., "Santa Clara, CA, US.").
-    Returns:
-        The index of the last occurrence of a valid comma, or -1 if no valid comma is found.
-    """
-    # find the last occurrence of a comma in the text
-    idx = text.rfind(",")
-    if idx == -1:
-        return -1
-    # check if the comma is in a number
-    if re.search(r'\d+,\d+', text[: idx + 1]):
-        # the comma is in a number, return -1
-        return -1
-
-    # check if the leftover text after the comma is too short
-    if len(text[idx + 1 :]) <= min_residual_length:
-        # the leftover text is too short, it may be an abbreviation, return -1
-        return -1
-
-    # the comma is not in a number, return the index of the comma
-    return idx
-
-
-class SimpleSegmentedTextAggregator(SimpleTextAggregator):
-    """A simple text aggregator that segments the text into sentences based on punctuation marks."""
-
-    def __init__(
-        self,
-        punctuation_marks: str | list[str] = ".,!?;:\n",
-        ignore_marks: str | list[str] = "*",
-        min_sentence_length: int = 0,
-        use_legacy_eos_detection: bool = False,
-        **kwargs,
-    ):
-        """
-        Args:
-            punctuation_marks: The punctuation marks to use for sentence detection.
-            ignore_marks: The strings to ignore in the text (e.g., "*").
-            min_sentence_length: The minimum length of a sentence to be considered.
-            use_legacy_eos_detection: Whether to use the legacy EOS detection from pipecat.
-            **kwargs: Additional arguments to pass to the SimpleTextAggregator constructor.
-        """
-        super().__init__(**kwargs)
-        self._use_legacy_eos_detection = use_legacy_eos_detection
-        self._min_sentence_length = min_sentence_length
-        self._ignore_marks = set(["*"] if ignore_marks is None else set(ignore_marks))
-        if not punctuation_marks:
-            self._punctuation_marks = list()
-        else:
-            punctuation_marks = (
-                [c for c in punctuation_marks] if isinstance(punctuation_marks, str) else punctuation_marks
-            )
-            if "." in punctuation_marks:
-                punctuation_marks.remove(".")
-            # put period at the end of the list to ensure it's the last punctuation mark to be matched
-            punctuation_marks += ["."]
-            self._punctuation_marks = punctuation_marks
-
-    def _find_segment_end(self, text: str) -> Optional[int]:
-        """find the end of text segment.
-
-        Args:
-            text: The text to find the end of the segment.
-
-        Returns:
-            The index of the end of the segment, or None if the text is too short.
-        """
-        # drop leading whitespace but keep trailing whitespace to
-        # allow "\n" to trigger the end of the sentence
-        text_len = len(text)
-        text = text.lstrip()
-        offset = text_len - len(text)
-        if len(text) < self._min_sentence_length:
-            return None
-
-        for punc in self._punctuation_marks:
-            if punc == ".":
-                idx = find_last_period_index(text)
-            elif punc == ",":
-                idx = find_last_comma_index(text)
-            else:
-                idx = text.find(punc)
-            if idx != -1:
-                # add the offset to the index to account for the leading whitespace
-                return idx + 1 + offset
-        return None
-
-    async def aggregate(self, text: str) -> AsyncIterator[Aggregation]:
-        """Aggregate the input text and return the first complete sentence in the text.
-
-        Args:
-            text: The text to aggregate.
-
-        Returns:
-            The first complete sentence in the text, or None if none is found.
-        """
-        result: Optional[str] = None
-        self._text += str(text)
-
-        eos_end_index = self._find_segment_end(self._text)
-
-        if not eos_end_index and not has_partial_decimal(self._text) and self._use_legacy_eos_detection:
-            # if the text doesn't have partial decimal, and no punctuation marks,
-            # we use match_endofsentence to find the end of the sentence
-            eos_end_index = match_endofsentence(self._text)
-
-        if eos_end_index:
-            result = self._text[:eos_end_index]
-            if len(result.strip()) < self._min_sentence_length:
-                logger.debug(
-                    f"Text is too short, skipping: `{result}`, full text: `{self._text}`, input text: `{text}`"
-                )
-                result = None
-            else:
-                logger.debug(f"Text Aggregator Result: `{result}`, full text: `{self._text}`, input text: `{text}`")
-                self._text = self._text[eos_end_index:]
-
-        if result:
-            for ignore_mark in self._ignore_marks:
-                result = result.replace(ignore_mark, "")
-            yield Aggregation(text=result, type=AggregationType.SENTENCE)

nemo/agents/voice_agent/utils/__init__.py

@@ -1,15 +0,0 @@
-# Copyright (c) 2025, 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.agents.voice_agent.utils.config_manager import ConfigManager

nemo/agents/voice_agent/utils/config_manager.py

@@ -1,312 +0,0 @@
-# Copyright (c) 2025, 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 typing import Any, Dict, Optional
-
-from loguru import logger
-from omegaconf import OmegaConf
-from pipecat.audio.vad.silero import VADParams
-
-from nemo.agents.voice_agent.pipecat.services.nemo.diar import NeMoDiarInputParams
-from nemo.agents.voice_agent.pipecat.services.nemo.stt import NeMoSTTInputParams
-
-
-class ConfigManager:
-    """
-    Manages configuration for the voice agent server.
-    Handles loading, merging, and providing access to all configuration parameters.
-    """
-
-    def __init__(self, server_base_path: str, server_config_path: Optional[str] = None):
-        """
-        Initialize the configuration manager.
-
-        Args:
-            config_path: Path to the main server configuration file.
-                        If None, uses default path from environment variable.
-        """
-        if not os.path.exists(server_base_path):
-            raise FileNotFoundError(f"Server base path not found at {server_base_path}")
-
-        self._server_base_path = server_base_path
-        if server_config_path is not None:
-            self._server_config_path = server_config_path
-        else:
-            self._server_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/default.yaml"
-
-        if not os.path.exists(self._server_config_path):
-            raise FileNotFoundError(f"Server configuration file not found at {self._server_config_path}")
-
-        # Load model registry
-        self.model_registry_path = f"{os.path.abspath(self._server_base_path)}/model_registry.yaml"
-        self.model_registry = self._load_model_registry()
-
-        # Load and process main configuration
-        self.server_config = self._load_server_config()
-
-        # Initialize configuration parameters
-        self._initialize_config_parameters()
-
-        self._generic_hf_llm_model_id = "hf_llm_generic"
-
-        logger.info(f"Configuration loaded from: {self._server_config_path}")
-        logger.info(f"Model registry loaded from: {self.model_registry_path}")
-
-    def _load_model_registry(self) -> Dict[str, Any]:
-        """Load model registry from YAML file."""
-        try:
-            return OmegaConf.load(self.model_registry_path)
-        except Exception as e:
-            logger.error(f"Failed to load model registry: {e}")
-            raise ValueError(f"Failed to load model registry: {e}")
-
-    def _load_server_config(self) -> OmegaConf:
-        """Load and process the main server configuration."""
-        server_config = OmegaConf.load(self._server_config_path)
-        server_config = OmegaConf.to_container(server_config, resolve=True)
-        server_config = OmegaConf.create(server_config)
-        return server_config
-
-    def _initialize_config_parameters(self):
-        """Initialize all configuration parameters from the loaded config."""
-        # Default constants
-        self.SAMPLE_RATE = 16000
-        self.RAW_AUDIO_FRAME_LEN_IN_SECS = 0.016
-        self.SYSTEM_PROMPT = " ".join(
-            [
-                "You are a helpful AI agent named Lisa.",
-                "Begin by warmly greeting the user and introducing yourself in one sentence.",
-                "Keep your answers concise and to the point.",
-            ]
-        )
-
-        # Transport configuration
-        self.TRANSPORT_AUDIO_OUT_10MS_CHUNKS = self.server_config.transport.audio_out_10ms_chunks
-
-        # VAD configuration
-        self.vad_params = VADParams(
-            confidence=self.server_config.vad.confidence,
-            start_secs=self.server_config.vad.start_secs,
-            stop_secs=self.server_config.vad.stop_secs,
-            min_volume=self.server_config.vad.min_volume,
-        )
-        # STT configuration
-        self._configure_stt()
-
-        # Diarization configuration
-        self._configure_diarization()
-
-        # Turn taking configuration
-        self._configure_turn_taking()
-
-        # LLM configuration
-        self._configure_llm()
-
-        # TTS configuration
-        self._configure_tts()
-
-    def _configure_stt(self):
-        """Configure STT parameters."""
-        self.STT_MODEL = self.server_config.stt.model
-        self.STT_DEVICE = self.server_config.stt.device
-        # Apply STT-specific configuration based on model type
-        # Try to get STT config file name from server config first
-        if self.server_config.stt.get("model_config", None) is not None:
-            yaml_file_name = os.path.basename(self.server_config.stt.model_config)
-        else:
-            # Get STT configuration from registry
-            if str(self.STT_MODEL).endswith(".nemo"):
-                model_name = os.path.splitext(os.path.basename(self.STT_MODEL))[0]
-            else:
-                model_name = self.STT_MODEL
-            if model_name in self.model_registry.stt_models:
-                yaml_file_name = self.model_registry.stt_models[model_name].yaml_id
-            else:
-                error_msg = f"STT model {model_name} is not in model registry: {self.model_registry.stt_models}."
-                logger.error(error_msg)
-                raise ValueError(error_msg)
-
-        stt_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/stt_configs/{yaml_file_name}"
-        if not os.path.exists(stt_config_path):
-            raise FileNotFoundError(f"STT config file not found at {stt_config_path}")
-        stt_config = OmegaConf.load(stt_config_path)
-
-        # merge stt config with server config
-        for key in stt_config:
-            if key in self.server_config.stt and self.server_config.stt[key] != stt_config[key]:
-                logger.info(
-                    f"STT config field `{key}` is overridden from `{self.server_config.stt[key]}` "
-                    f"to `{stt_config[key]}` by {stt_config_path}"
-                )
-            self.server_config.stt[key] = stt_config[key]
-
-        logger.info(f"Final STT config: {self.server_config.stt}")
-
-        audio_chunk_size_in_secs = self.server_config.stt.get("audio_chunk_size_in_secs", 0.08)
-        buffer_size = audio_chunk_size_in_secs // self.RAW_AUDIO_FRAME_LEN_IN_SECS
-        self.stt_params = NeMoSTTInputParams(
-            att_context_size=self.server_config.stt.att_context_size,
-            frame_len_in_secs=self.server_config.stt.frame_len_in_secs,
-            raw_audio_frame_len_in_secs=self.RAW_AUDIO_FRAME_LEN_IN_SECS,
-            buffer_size=buffer_size,
-        )
-
-    def _configure_diarization(self):
-        """
-        Configure diarization parameters.
-        Currently only NeMo End-to-End Diarization is supported.
-        """
-        self.DIAR_MODEL = self.server_config.diar.model
-        self.USE_DIAR = self.server_config.diar.enabled
-        self.diar_params = NeMoDiarInputParams(
-            frame_len_in_secs=self.server_config.diar.frame_len_in_secs,
-            threshold=self.server_config.diar.threshold,
-        )
-
-    def _configure_turn_taking(self):
-        """Configure turn taking parameters."""
-        self.TURN_TAKING_BACKCHANNEL_PHRASES_PATH = self.server_config.turn_taking.backchannel_phrases_path
-        self.TURN_TAKING_MAX_BUFFER_SIZE = self.server_config.turn_taking.max_buffer_size
-        self.TURN_TAKING_BOT_STOP_DELAY = self.server_config.turn_taking.bot_stop_delay
-
-    def _configure_llm(self):
-        """Configure LLM parameters."""
-        llm_model_id = self.server_config.llm.model
-        is_registry_model = False
-
-        # Try to get LLM config file name from server config first
-        if self.server_config.llm.get("model_config", None) is not None:
-            yaml_file_name = os.path.basename(self.server_config.llm.model_config)
-        else:
-            # Get LLM configuration from registry
-            if llm_model_id in self.model_registry.llm_models:
-                yaml_file_name = self.model_registry.llm_models[llm_model_id].yaml_id
-                is_registry_model = True
-            else:
-                logger.warning(
-                    f"LLM model {llm_model_id} is not included in the model registry. "
-                    "Using a generic HuggingFace LLM config instead."
-                )
-                yaml_file_name = self.model_registry.llm_models[self._generic_hf_llm_model_id].yaml_id
-
-        # Load and merge LLM configuration
-        llm_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/llm_configs/{yaml_file_name}"
-
-        if (
-            is_registry_model
-            and self.model_registry.llm_models[llm_model_id].get("reasoning_supported", False)
-            and self.server_config.llm.get("enable_reasoning", False)
-        ):
-            llm_config_path = llm_config_path.replace(".yaml", "_think.yaml")
-
-        if not os.path.exists(llm_config_path):
-            raise FileNotFoundError(f"LLM config file not found at {llm_config_path}")
-        logger.info(f"Loading LLM config from: {llm_config_path}")
-
-        llm_config = OmegaConf.load(llm_config_path)
-        # merge llm config with server config
-        # print the override keys
-        for key in llm_config:
-            if key in self.server_config.llm and self.server_config.llm[key] != llm_config[key]:
-                logger.info(
-                    f"LLM config field `{key}` is overridden from `{self.server_config.llm[key]}` to "
-                    f"`{llm_config[key]}` by {llm_config_path}"
-                )
-            self.server_config.llm[key] = llm_config[key]
-
-        logger.info(f"Final LLM config: {self.server_config.llm}")
-
-        # Configure system prompt
-        self.SYSTEM_ROLE = self.server_config.llm.get("system_role", "system")
-        if self.server_config.llm.get("system_prompt", None) is not None:
-            system_prompt = self.server_config.llm.system_prompt
-            if os.path.isfile(system_prompt):
-                with open(system_prompt, "r") as f:
-                    system_prompt = f.read()
-            self.SYSTEM_PROMPT = system_prompt
-        else:
-            logger.info(f"No system prompt provided, using default system prompt: {self.SYSTEM_PROMPT}")
-
-        if self.server_config.llm.get("system_prompt_suffix", None) is not None:
-            self.SYSTEM_PROMPT += "\n" + self.server_config.llm.system_prompt_suffix
-            logger.info(f"Adding system prompt suffix: {self.server_config.llm.system_prompt_suffix}")
-
-        logger.info(f"System prompt: {self.SYSTEM_PROMPT}")
-
-    def _configure_tts(self):
-        """Configure TTS parameters."""
-        tts_model_id = self.server_config.tts.model
-
-        # Try to get TTS config file name from server config first
-        if self.server_config.tts.get("model_config", None) is not None:
-            yaml_file_name = os.path.basename(self.server_config.tts.model_config)
-        else:
-            # Get TTS configuration from registry
-            if tts_model_id in self.model_registry.tts_models:
-                yaml_file_name = self.model_registry.tts_models[tts_model_id].yaml_id
-            else:
-                error_msg = f"TTS model {tts_model_id} is not in model registry: {self.model_registry.tts_models}"
-                logger.error(error_msg)
-                raise ValueError(error_msg)
-
-        tts_config_path = f"{os.path.abspath(self._server_base_path)}/server_configs/tts_configs/{yaml_file_name}"
-        if not os.path.exists(tts_config_path):
-            raise FileNotFoundError(f"Default TTS config file not found at {tts_config_path}")
-        tts_config = OmegaConf.load(tts_config_path)
-
-        # merge tts config with server config
-        for key in tts_config:
-            if key in self.server_config.tts and self.server_config.tts[key] != tts_config[key]:
-                logger.info(
-                    f"TTS config field `{key}` is overridden from `{self.server_config.tts[key]}` to "
-                    f"`{tts_config[key]}` by {tts_config_path}"
-                )
-            self.server_config.tts[key] = tts_config[key]
-
-        logger.info(f"Final TTS config: {self.server_config.tts}")
-
-        # Extract TTS parameters
-        self.TTS_MAIN_MODEL_ID = self.server_config.tts.get("main_model_id", None)
-        self.TTS_SUB_MODEL_ID = self.server_config.tts.get("sub_model_id", None)
-        self.TTS_DEVICE = self.server_config.tts.get("device", None)
-
-        # Handle optional TTS parameters
-        self.TTS_THINK_TOKENS = self.server_config.tts.get("think_tokens", None)
-        if self.TTS_THINK_TOKENS is not None:
-            self.TTS_THINK_TOKENS = OmegaConf.to_container(self.TTS_THINK_TOKENS)
-
-        self.TTS_EXTRA_SEPARATOR = self.server_config.tts.get("extra_separator", None)
-        if self.TTS_EXTRA_SEPARATOR is not None:
-            self.TTS_EXTRA_SEPARATOR = OmegaConf.to_container(self.TTS_EXTRA_SEPARATOR)
-
-    def get_server_config(self) -> OmegaConf:
-        """Get the complete server configuration."""
-        return self.server_config
-
-    def get_model_registry(self) -> Dict[str, Any]:
-        """Get the model registry configuration."""
-        return self.model_registry
-
-    def get_vad_params(self) -> VADParams:
-        """Get VAD parameters."""
-        return self.vad_params
-
-    def get_stt_params(self) -> NeMoSTTInputParams:
-        """Get STT parameters."""
-        return self.stt_params
-
-    def get_diar_params(self) -> NeMoDiarInputParams:
-        """Get diarization parameters."""
-        return self.diar_params

nemo/agents/voice_agent/utils/tool_calling/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2025, 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/agents/voice_agent/utils/tool_calling/basic_tools.py

@@ -1,72 +0,0 @@
-# Copyright (c) 2025, 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 asyncio
-import python_weather
-from loguru import logger
-from pipecat.frames.frames import LLMTextFrame, TTSSpeakFrame
-from pipecat.processors.frame_processor import FrameDirection
-from pipecat.services.llm_service import FunctionCallParams
-
-HTTP_REQUEST_TIMEOUT = 10.0
-
-
-async def tool_get_city_weather(params: FunctionCallParams, city_name: str):
-    """Get the current weather of a city. The result includes city name, weather description,
-    temperature, wind speed, wind direction, precipitation, humidity, visibility, and UV index.
-
-    Args:
-        city_name: The name of the city to get the weather of. For example, "London", "Beijing", "Paris".
-                Other examples are: "Paris, TX, US", "Paris, FR" and "Tokyo, JP".
-    """
-    message = f"Looking up weather data for {city_name}. Please wait a moment..."
-    # Send the message to upstream so that RTVI can log it while doesn't block the actual tool call.
-    await params.llm.push_frame(LLMTextFrame(message), direction=FrameDirection.UPSTREAM)
-    # Send the message to TTS directly so that the user can hear it immediately.
-    await params.llm.push_frame(TTSSpeakFrame(message))
-
-    # The measuring unit defaults to metric (Celsius)
-    # Use imperial for Fahrenheit: python_weather.IMPERIAL
-    async with python_weather.Client(unit=python_weather.METRIC) as client:
-        # Fetch a weather forecast from a city
-        logger.debug(f"Fetching weather forecast for `{city_name}`")
-        try:
-            weather: python_weather.Forecast = await asyncio.wait_for(
-                client.get(city_name),
-                timeout=HTTP_REQUEST_TIMEOUT,
-            )
-        except asyncio.TimeoutError:
-            error_msg = f"python_weather API request timed out after {HTTP_REQUEST_TIMEOUT} seconds for `{city_name}`"
-            logger.error(error_msg)
-            await params.result_callback({"error": error_msg})
-            return
-        except Exception as e:
-            error_msg = f"Error fetching weather forecast for `{city_name}`: {str(e)}"
-            logger.error(error_msg)
-            await params.result_callback({"error": error_msg})
-            return
-
-        results = {
-            "city": city_name,
-            "description": str(weather.description),
-            "temperature": f"{weather.temperature} degrees Celsius",
-            "wind_speed": f"{weather.wind_speed} kilometers per hour",
-            "wind_direction": str(weather.wind_direction.name),
-            "precipitation": f"{weather.precipitation} millimeters",
-            "humidity": f"{weather.humidity} percent",
-            "visibility": f"{weather.visibility} kilometers",
-            "uv_index": str(weather.ultraviolet),
-        }
-        logger.debug(f"Weather results for {city_name}: {results}")
-        await params.result_callback(results)

nemo/agents/voice_agent/utils/tool_calling/mixins.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2025, 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 loguru import logger
-from pipecat.adapters.schemas.direct_function import DirectFunction
-from pipecat.adapters.schemas.tools_schema import ToolsSchema
-from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
-from pipecat.services.openai.llm import OpenAILLMService
-
-
-class ToolCallingMixin:
-    """
-    A mixin class for tool calling.
-    Subclasses must implement the `setup_tool_calling` method to register all available tools
-    using `self.register_direct_function()`. Then the `__init__` method of the subclass should
-    call the `setup_tool_calling` method to register the tools.
-    """
-
-    def setup_tool_calling(self):
-        """
-        Setup the tool calling mixin by registering all available tools using self.register_direct_function().
-        """
-        raise NotImplementedError(
-            "Subclasses must implement this method to register all available functions "
-            "using self.register_direct_function()"
-        )
-
-    def register_direct_function(self, function_name: str, function: DirectFunction):
-        """
-        Register a direct function to be called by the LLM.
-
-        Args:
-            function_name: The name of the function to register.
-            function: The direct function to register.
-        """
-        if not hasattr(self, "direct_functions"):
-            self.direct_functions = {}
-        logger.info(
-            f"[{self.__class__.__name__}] Registering direct function name {function_name} to "
-            f"{function.__module__ + '.' + function.__qualname__}"
-        )
-        self.direct_functions[function_name] = function
-
-    @property
-    def available_tools(self) -> dict[str, DirectFunction]:
-        """
-        Return a dictionary of available tools, where the key is the tool name and the value is the direct function.
-        """
-        tools = {}
-        for function_name, function in self.direct_functions.items():
-            tools[function_name] = function
-        return tools
-
-
-def register_direct_tools_to_llm(
-    *,
-    llm: OpenAILLMService,
-    context: OpenAILLMContext,
-    tool_mixins: list[ToolCallingMixin] = [],
-    tools: list[DirectFunction] = [],
-    cancel_on_interruption: bool = True,
-) -> None:
-    """
-    Register direct tools to the LLM.
-    Args:
-        llm: The LLM service to use.
-        context: The LLM context to use.
-        tools: The list of tools (instances of either `DirectFunction` or `ToolCallingMixin`) to use.
-    """
-    all_tools = []
-    for tool in tool_mixins:
-        if not isinstance(tool, ToolCallingMixin):
-            logger.warning(f"Tool {tool.__class__.__name__} is not a ToolCallingMixin, skipping.")
-            continue
-        for function_name, function in tool.available_tools.items():
-            logger.info(f"Registering direct function {function_name} from {tool.__class__.__name__}")
-            all_tools.append(function)
-
-    for tool in tools:
-        logger.info(f"Registering direct function: {tool.__module__ + '.' + tool.__qualname__}")
-        all_tools.append(tool)
-
-    if not all_tools:
-        logger.warning("No direct tools provided.")
-        return
-    else:
-        logger.info(f"Registering {len(all_tools)} direct tools to the LLM.")
-
-    tools_schema = ToolsSchema(standard_tools=all_tools)
-    context.set_tools(tools_schema)
-
-    for tool in all_tools:
-        llm.register_direct_function(tool, cancel_on_interruption=cancel_on_interruption)

nemo/collections/__init__.py

@@ -1,13 +0,0 @@
-# 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/README.md

@@ -1,37 +0,0 @@
-# Automatic Speech Recognition (ASR)
-
-## Key Features
-
-* [HuggingFace Space for Audio Transcription (File, Microphone and YouTube)](https://huggingface.co/spaces/smajumdar/nemo_multilingual_language_id)
-* [Pretrained models](https://ngc.nvidia.com/catalog/collections/nvidia:nemo_asr) available in 14+ languages
-* [Automatic Speech Recognition (ASR)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/intro.html)
-    * Supported ASR [models](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/models.html):
-        * Jasper, QuartzNet, CitriNet, ContextNet
-        * Conformer-CTC, Conformer-Transducer, FastConformer-CTC, FastConformer-Transducer
-        * Squeezeformer-CTC and Squeezeformer-Transducer
-        * LSTM-Transducer (RNNT) and LSTM-CTC
-    * Supports the following decoders/losses:
-        * CTC
-        * Transducer/RNNT
-        * Hybrid Transducer/CTC
-        * NeMo Original [Multi-blank Transducers](https://arxiv.org/abs/2211.03541) and [Token-and-Duration Transducers (TDT)](https://arxiv.org/abs/2304.06795)
-    * Streaming/Buffered ASR (CTC/Transducer) - [Chunked Inference Examples](https://github.com/NVIDIA/NeMo/tree/stable/examples/asr/asr_chunked_inference)
-    * [Cache-aware Streaming Conformer](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/models.html#cache-aware-streaming-conformer) with multiple lookaheads (including microphone streaming [tutorial](https://github.com/NVIDIA/NeMo/blob/main/tutorials/asr/Online_ASR_Microphone_Demo_Cache_Aware_Streaming.ipynb).
-    * Beam Search decoding
-    * [Language Modelling for ASR (CTC and RNNT)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/asr_language_modeling.html): N-gram LM in fusion with Beam Search decoding, Neural Rescoring with Transformer
-    * [Support of long audios for Conformer with memory efficient local attention](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/results.html#inference-on-long-audio)
-* [Speech Classification, Speech Command Recognition and Language Identification](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speech_classification/intro.html): MatchboxNet (Command Recognition), AmberNet (LangID)
-* [Voice activity Detection (VAD)](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/stable/asr/speech_classification/models.html#marblenet-vad): MarbleNet
-    * ASR with VAD Inference - [Example](https://github.com/NVIDIA/NeMo/tree/stable/examples/asr/asr_vad)
-* [Speaker Recognition](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speaker_recognition/intro.html): TitaNet, ECAPA_TDNN, SpeakerNet
-* [Speaker Diarization](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speaker_diarization/intro.html)
-    * Clustering Diarizer: TitaNet, ECAPA_TDNN, SpeakerNet
-    * Neural Diarizer: Sortformer
-* [Speech Intent Detection and Slot Filling](https://docs.nvidia.com/deeplearning/nemo/user-guide/docs/en/main/asr/speech_intent_slot/intro.html): Conformer-Transformer
-
-You can also get a high-level overview of NeMo ASR by watching the talk *NVIDIA NeMo: Toolkit for Conversational AI*, presented at PyData Yerevan 2022:
-
-
-[![NVIDIA NeMo: Toolkit for Conversational AI](https://img.youtube.com/vi/J-P6Sczmas8/maxres3.jpg
-)](https://www.youtube.com/embed/J-P6Sczmas8?mute=0&start=14&autoplay=0
- "NeMo presentation at PyData@Yerevan 2022")

nemo/collections/asr/__init__.py

@@ -1,25 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,95 +0,0 @@
-# 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

@@ -1,562 +0,0 @@
-# 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 typing import Dict, List, Optional, Tuple
-
-import numpy as np
-import torch
-
-from nemo.collections.asr.parts.utils.speaker_utils import convert_rttm_line, get_subsegments
-from nemo.collections.common.parts.preprocessing.collections import EndtoEndDiarizationSpeechLabel
-from nemo.core.classes import Dataset
-from nemo.core.neural_types import AudioSignal, LengthsType, NeuralType, ProbsType
-from nemo.utils import logging
-
-
-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 _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,
-        fb_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.fb_featurizer = fb_featurizer
-        # STFT and subsampling factor parameters
-        self.n_fft = self.fb_featurizer.n_fft
-        self.hop_length = self.fb_featurizer.hop_length
-        self.stft_pad_amount = self.fb_featurizer.stft_pad_amount
-        self.subsampling_factor = subsampling_factor
-        # Annotation and target length parameters
-        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
-        self.global_rank = global_rank
-
-    def __len__(self):
-        return len(self.collection)
-
-    def get_frame_count_from_time_series_length(self, seq_len):
-        """
-        This function is used to get the sequence length of the audio signal. This is required to match
-        the feature frame length with ASR (STT) models. This function is copied from
-        NeMo/nemo/collections/asr/parts/preprocessing/features.py::FilterbankFeatures::get_seq_len.
-
-        Args:
-            seq_len (int):
-                The sequence length of the time-series data.
-
-        Returns:
-            seq_len (int):
-                The sequence length of the feature frames.
-        """
-        pad_amount = self.stft_pad_amount * 2 if self.stft_pad_amount is not None else self.n_fft // 2 * 2
-        seq_len = torch.floor_divide((seq_len + pad_amount - self.n_fft), self.hop_length).to(dtype=torch.long)
-        frame_count = int(np.ceil(seq_len / self.subsampling_factor))
-        return frame_count
-
-    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:
-                `EndtoEndDiarizationSpeechLabel` 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:
-                `EndtoEndDiarizationSpeechLabel` 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 length should be following the ASR feature extraction convention: Use self.get_frame_count_from_time_series_length.
-        target_len = self.get_segment_timestamps(duration=session_len_sec, sample_rate=self.featurizer.sample_rate)
-        target_len = torch.clamp(target_len, max=self.get_frame_count_from_time_series_length(audio_signal.shape[0]))
-
-        targets = self.parse_rttm_for_targets_and_lens(
-            rttm_file=sample.rttm_file, offset=offset, duration=session_len_sec, target_len=target_len
-        )
-        targets = targets[: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,
-        fb_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,
-            fb_featurizer=fb_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

@@ -1,114 +0,0 @@
-# Copyright (c) 2025, 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
-from nemo.utils import logging
-
-
-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))
-
-    def __getitem__(self, cuts) -> Tuple[torch.Tensor, ...]:
-        # NOTE: This end-to-end diarization dataloader only loads the 1st ch of the audio file.
-        # Process cuts in a single loop: convert to mono and compute speaker activities
-        mono_cuts = []
-        speaker_activities = []
-        for cut in cuts:
-            if cut.num_channels is not None and cut.num_channels > 1:
-                logging.warning(
-                    "Multiple channels detected in cut '%s' (%d channels). "
-                    "Only the first channel will be used; remaining channels are ignored.",
-                    cut.id,
-                    cut.num_channels,
-                )
-            mono_cut = cut.with_channels(channels=[0])
-            mono_cuts.append(mono_cut)
-
-            speaker_activity = speaker_to_target(
-                a_cut=mono_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,
-                boundary_segments=True,
-            )
-            # This line prevents dimension mismatch error in the collate_matrices function.
-            if speaker_activity.shape[1] > self.num_speakers:
-                logging.warning(
-                    "Number of speakers in the target %s is greater than "
-                    "the maximum number of speakers %s. Truncating extra speakers. "
-                    "Set the `num_speakers` to higher value to avoid this warning.",
-                    speaker_activity.shape[1],
-                    self.num_speakers,
-                )
-                speaker_activity = speaker_activity[:, : self.num_speakers]
-            speaker_activities.append(speaker_activity)
-
-        cuts = type(cuts).from_cuts(mono_cuts)
-        audio, audio_lens, cuts = self.load_audio(cuts)
-        targets = collate_matrices(speaker_activities).to(audio.dtype)  # (B, T, N)
-
-        if targets.shape[2] > self.num_speakers:
-            targets = targets[:, :, : self.num_speakers]
-        elif targets.shape[2] < self.num_speakers:
-            targets = torch.nn.functional.pad(
-                targets, (0, self.num_speakers - targets.shape[2]), mode='constant', value=0
-            )
-
-        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_eou_label_lhotse.py

@@ -1,524 +0,0 @@
-# Copyright (c) 2025, 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
-from dataclasses import dataclass
-from typing import Dict, List, Optional
-
-import numpy as np
-import torch.utils.data
-from lhotse.cut import Cut, CutSet, MixedCut
-from lhotse.dataset import AudioSamples
-from lhotse.dataset.collation import collate_vectors
-from omegaconf import DictConfig, OmegaConf
-
-from nemo.collections.asr.parts.preprocessing.perturb import process_augmentations
-from nemo.collections.asr.parts.preprocessing.segment import AudioSegment
-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
-from nemo.utils import logging
-
-NON_SPEECH_LABEL = 0
-SPEECH_LABEL = 1
-EOU_LABEL = 2
-EOB_LABEL = 3
-EOU_STRING = '<EOU>'
-EOB_STRING = '<EOB>'
-
-# These augmentations are not supported yet, since they will need to change the SOU/EOU timestamps
-EOU_INVALID_AUGMENTATIONS = ['random_segment', 'speed', 'time_stretch']
-
-
-@dataclass
-class AudioToTextEOUBatch:
-    """
-    Data class for ASR-EOU batch.
-    """
-
-    sample_ids: List | None = None
-    audio_filepaths: List | None = None
-    audio_signal: torch.Tensor | None = None
-    audio_lengths: torch.Tensor | None = None
-    text_tokens: torch.Tensor | None = None
-    text_token_lengths: torch.Tensor | None = None
-    eou_targets: torch.Tensor | None = None
-    eou_target_lengths: torch.Tensor | None = None
-
-
-@dataclass
-class RandomPaddingConfig:
-    prob: float = 0.9  # probability of applying padding
-    min_pad_duration: float = 0.0  # minimum duration of pre/post padding in seconds
-    max_pad_duration: float = 5.0  # maximum duration of pre/post padding in seconds
-    max_total_duration: float = 40.0  # maximum total duration of the padded audio in seconds
-    min_pre_pad_duration: float = 0.0  # minimum duration of pre-padding in seconds
-    min_post_pad_duration: float = 2.0  # minimum duration of post-padding in seconds
-    pad_distribution: str = 'uniform'  # distribution of padding duration, 'uniform' or 'normal' or 'constant'
-    normal_mean: float = 0.5  # mean of normal distribution for padding duration
-    normal_std: float = 2.0  # standard deviation of normal distribution for padding duration
-    pre_pad_duration: float = 0.2  # amount of left-padding when pad_distribution='constant'
-    post_pad_duration: float = 3.0  # amount of right-padding when pad_distribution='constant'
-
-
-class LhotseSpeechToTextBpeEOUDataset(torch.utils.data.Dataset):
-    """
-    This dataset processes the audio data and the corresponding text data to generate the ASR labels,
-    along with EOU labels for each frame. The audios used in this dataset should only contain speech with
-    NO precedding or following silence. The dataset also randomly pads non-speech frames before and after
-    the audio signal for training EOU prediction task.
-
-    To generate EOU labels, the last frame of utterance will be marked as "end of utterance" (labeled as `2`),
-    while if it's a backchannel utterance it'll be marked asd "end of backchannel" (labeled as `3`).
-    The rest of the speech frames will be marked as "speech" (labeled as `1`).
-    The padded non-speech signals will be marked as "non-speech" (labeled as 0).
-
-    Args:
-        cfg: DictConfig object container following keys, usually taken from your `model.train_ds`
-            or `model.validation_ds` config:
-        ```
-            sample_rate: # int, Sample rate of the audio signal
-            window_stride: # float, Window stride for audio encoder
-            subsampling_factor: # Subsampling factor for audio encoder
-            random_padding:  # Random padding configuration
-                prob: 0.9  # probability of applying padding
-                min_pad_duration: 0.5  # minimum duration of pre/post padding in seconds
-                max_pad_duration: 2.0 # maximum duration of pre/post padding in seconds
-                max_total_duration: 30.0  # maximum total duration of the padded audio in seconds
-                pad_distribution: 'uniform'  # distribution of padding duration, 'uniform' or 'normal' or 'constant'
-                normal_mean: 0.5  # mean of normal distribution for padding duration
-                normal_std: 2.0  # standard deviation of normal distribution for padding duration
-                pre_pad_duration: 0.2 # amount of left-padding when pad_distribution='constant'
-                post_pad_duration: 3.0  # amount of right-padding when pad_distribution='constant'
-        ```
-
-    Returns:
-        audio: torch.Tensor of audio signal
-        audio_lens: torch.Tensor of audio signal length
-        text_tokens: torch.Tensor of text text_tokens
-        text_token_lens: torch.Tensor of text token length
-        eou_targets (optional): torch.Tensor of EOU labels
-        eou_target_lens (optional): torch.Tensor of EOU label length
-
-    The input manifest should be a jsonl file where each line is a python dictionary.
-    Example manifest sample:
-    {
-        "audio_filepath": "/path/to/audio.wav",
-        "offset": 0.0,
-        "duration": 6.0,
-        "sou_time": [0.3, 4.0],
-        "eou_time": [1.3, 4.5],
-        "utterances": ["Tell me a joke", "Ah-ha"],
-        "is_backchannel": [False, True],
-    }
-
-    Padding logic:
-    0. Don't pad when `random_padding` is None or during validation/test
-    1. randomly draw a probability to decide whether to apply padding
-    2. if not padding or audio duration is longer than the maximum duration,
-        1) return the original audio and EOU labels
-    3. if apply padding,
-        1) get the max padding duration based on the maximum total duration and the audio duration
-        2) randomly draw a total padding duration based on the given distribution
-        3) randomly split the total padding duration into pre-padding and post-padding
-        4) randomly generate the non-speech signal (audio signal=0) for pre-padding and post-padding
-        5) concatenate the pre-padding, audio, and post-padding to get the padded audio signal
-        6) update the EOU labels accordingly
-
-    """
-
-    @property
-    def output_types(self) -> Optional[Dict[str, NeuralType]]:
-        """Define the output types of the dataset."""
-        return {
-            'audio': NeuralType(('B', 'T'), AudioSignal()),
-            'audio_lens': NeuralType(tuple('B'), LengthsType()),
-            'eou_targets': NeuralType(('B', 'T'), LabelsType()),
-            'eou_target_lens': NeuralType(tuple('B'), LengthsType()),
-            'text_tokens': NeuralType(tuple('B', 'T'), LengthsType(), optional=True),
-            'text_token_lens': NeuralType(tuple('B'), LengthsType(), optional=True),
-        }
-
-    def __init__(self, cfg: DictConfig, tokenizer: TokenizerSpec, return_cuts: bool = False):
-        super().__init__()
-        self.cfg = cfg
-        self.return_cuts = return_cuts
-        self.eou_string = self.cfg.get('eou_string', EOU_STRING)
-        self.eob_string = self.cfg.get('eob_string', EOB_STRING)
-        if cfg.get('check_tokenizer', True):
-            self._check_special_tokens(tokenizer)
-
-        self.tokenizer = TokenizerWrapper(tokenizer)
-        self.load_audio = AudioSamples(fault_tolerant=True)
-        self.sample_rate = self.cfg.get('sample_rate', 16000)
-        self.window_stride = self.cfg.get('window_stride', 0.01)
-        self.num_sample_per_mel_frame = int(
-            self.window_stride * self.sample_rate
-        )  # 160 samples for every 1ms by default
-        self.num_mel_frame_per_target_frame = int(self.cfg.get('subsampling_factor', 8))
-        self.add_sep_before_eou = self.cfg.get('add_sep_before_eou', False)
-        self.add_eou_to_text = self.cfg.get('add_eou_to_text', True)
-        self.pad_eou_label_secs = self.cfg.get('pad_eou_label_secs', 0.0)
-        self.padding_cfg = self.cfg.get('random_padding', None)
-        if self.padding_cfg is not None:
-            self.padding_cfg = OmegaConf.to_container(self.padding_cfg, resolve=True)
-            self.padding_cfg = RandomPaddingConfig(**self.padding_cfg)
-        self.ignore_eob_label = self.cfg.get('ignore_eob_label', False)
-        self.augmentor = None
-        if self.cfg.get('augmentor', None) is not None:
-            augmentor = {}
-            aug_cfg = OmegaConf.to_container(self.cfg.augmentor, resolve=True)
-            for k, v in aug_cfg.items():
-                if k in EOU_INVALID_AUGMENTATIONS:
-                    logging.warning(f"EOU dataset does not support {k} augmentation yet, skipping.")
-                    continue
-                augmentor[k] = v
-
-            if len(augmentor) > 0:
-                logging.info(f"EOU dataset will apply augmentations: {augmentor}")
-                self.augmentor = process_augmentations(augmentor)
-
-    def _check_special_tokens(self, tokenizer: TokenizerSpec):
-        """
-        Check if the special tokens are in the tokenizer vocab.
-        """
-        special_tokens = set([self.eou_string, self.eob_string])
-        vocab_size = tokenizer.vocab_size
-        special_tokens_in_vocab = set([tokenizer.ids_to_text(vocab_size - 1), tokenizer.ids_to_text(vocab_size - 2)])
-        if special_tokens != special_tokens_in_vocab:
-            raise ValueError(
-                f"Input special tokens {special_tokens} don't match with the tokenizer vocab {special_tokens_in_vocab}. "
-                f"Please add them to tokenizer or change input `eou_string` and/or `eob_string` accordingly. "
-                "Special tokens should be added as the last two tokens in the new tokenizer. "
-                "Please refer to scripts/asr_end_of_utterance/tokenizers/add_special_tokens_to_sentencepiece.py for details."
-            )
-
-    def __getitem__(self, cuts: CutSet) -> AudioToTextEOUBatch:
-        audio, audio_lens, cuts = self.load_audio(cuts)
-        audio_signals = []
-        audio_lengths = []
-        eou_targets = []
-        text_tokens = []
-        sample_ids = []
-        audio_filepaths = []
-
-        for i in range(len(cuts)):
-            c = cuts[i]
-            if isinstance(c, MixedCut):
-                c = c.first_non_padding_cut
-
-            sample_ids.append(c.id)
-            audio_filepaths.append(c.recording.sources[0].source)
-
-            audio_i = audio[i]
-            audio_len_i = audio_lens[i]
-
-            # Get EOU labels and text tokens
-            eou_targets_i = self._get_frame_labels(c, audio_len_i)
-            text_tokens_i = self._get_text_tokens(c)
-
-            # Maybe apply random padding to both sides of the audio
-            audio_i, audio_len_i, eou_targets_i = self._random_pad_audio(audio_i, audio_len_i, eou_targets_i)
-
-            # Maybe apply augmentations to the audio signal after padding
-            audio_i, audio_len_i = self._maybe_augment_audio(audio_i, audio_len_i)
-
-            # Append the processed audio, EOU labels, and text tokens to the lists
-            audio_signals.append(audio_i)
-            audio_lengths.append(audio_len_i)
-            eou_targets.append(eou_targets_i)
-            text_tokens.append(text_tokens_i)
-
-        audio_signals = collate_vectors(audio_signals, padding_value=0)
-        audio_lengths = torch.tensor(audio_lengths, dtype=torch.long)
-        eou_target_lens = torch.tensor([t.size(0) for t in eou_targets], dtype=torch.long)
-        eou_targets = collate_vectors(eou_targets, padding_value=0)
-        text_token_lens = torch.tensor([t.size(0) for t in text_tokens], dtype=torch.long)
-        text_tokens = collate_vectors(text_tokens, padding_value=0)
-
-        if self.return_cuts:
-            return audio_signals, audio_lengths, cuts
-
-        return AudioToTextEOUBatch(
-            sample_ids=sample_ids,
-            audio_filepaths=audio_filepaths,
-            audio_signal=audio_signals,
-            audio_lengths=audio_lengths,
-            text_tokens=text_tokens,
-            text_token_lengths=text_token_lens,
-            eou_targets=eou_targets,
-            eou_target_lengths=eou_target_lens,
-        )
-
-    def _audio_len_to_frame_len(self, num_samples: int):
-        """
-        Convert the raw audio length to the number of frames after audio encoder.
-
-        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))
-        """
-        mel_frame_count = math.ceil((num_samples + 1) / self.num_sample_per_mel_frame)
-        hidden_length = math.ceil(mel_frame_count / self.num_mel_frame_per_target_frame)
-        return hidden_length
-
-    def _repeat_eou_labels(self, eou_targets: torch.Tensor) -> torch.Tensor:
-        """
-        Repeat EOU labels according to self.pad_eou_label_secs
-        Args:
-            eou_targets: torch.Tensor of EOU labels, shape [T]
-        Returns:
-            eou_targets: torch.Tensor of padded EOU labels, shape [T]
-        """
-        if not self.pad_eou_label_secs or self.pad_eou_label_secs <= 0:
-            return eou_targets
-
-        eou_len = self._audio_len_to_frame_len(int(self.pad_eou_label_secs * self.sample_rate))
-
-        i = 0
-        while i < eou_targets.size(0):
-            if eou_targets[i] == EOU_LABEL or eou_targets[i] == EOB_LABEL:
-                # repeat the label for the next eou_len samples
-                start = i
-                end = min(i + eou_len, eou_targets.size(0))
-                j = start + 1
-                while j < end:
-                    if eou_targets[j] != NON_SPEECH_LABEL:
-                        # do not overwrite the label if it's not non-speech
-                        break
-                    j += 1
-                end = min(j, end)
-                # fill the non-speech label with the current EOU/EOB label
-                eou_targets[start:end] = eou_targets[i]
-                i = end
-            else:
-                i += 1
-        return eou_targets
-
-    def _get_frame_labels(self, cut: Cut, num_samples: int):
-        """
-        Get the frame-level EOU labels for a single audio segment.
-        Args:
-            cut: Cut object
-            num_samples: int, the number of samples in the audio segment
-        Returns:
-            eou_targets: torch.Tensor of EOU labels, shape [T]
-        """
-        hidden_length = self._audio_len_to_frame_len(num_samples)
-        if not "sou_time" in cut.custom or not "eou_time" in cut.custom:
-            # assume only single speech segment
-            text = cut.supervisions[0].text
-            if not text:
-                # skip empty utterances
-                return torch.zeros(hidden_length).long()
-            eou_targets = torch.ones(hidden_length).long()  # speech label
-            eou_targets[-1] = EOU_LABEL  # by default it's end of utterance
-            if cut.has_custom("is_backchannel") and cut.custom["is_backchannel"] and not self.ignore_eob_label:
-                eou_targets[-1] = EOB_LABEL  # end of backchannel
-            return eou_targets
-
-        sou_time = cut.custom["sou_time"]
-        eou_time = cut.custom["eou_time"]
-        if not isinstance(sou_time, list):
-            sou_time = [sou_time]
-        if not isinstance(eou_time, list):
-            eou_time = [eou_time]
-
-        assert len(sou_time) == len(
-            eou_time
-        ), f"Number of SOU time and EOU time do not match: SOU ({sou_time}) vs EOU ({eou_time})"
-
-        if cut.has_custom("is_backchannel"):
-            is_backchannel = cut.custom["is_backchannel"]
-            if not isinstance(is_backchannel, list):
-                is_backchannel = [is_backchannel]
-            assert len(sou_time) == len(
-                is_backchannel
-            ), f"Number of SOU and backchannel do not match: SOU ({len(sou_time)}) vs backchannel ({len(is_backchannel)})"
-        else:
-            is_backchannel = [False] * len(sou_time)
-
-        eou_targets = torch.zeros(hidden_length).long()
-        for i in range(len(sou_time)):
-            if sou_time[i] is None or eou_time[i] is None or sou_time[i] < 0 or eou_time[i] < 0:
-                # skip empty utterances
-                continue
-            sou_idx = self._audio_len_to_frame_len(int((sou_time[i] - cut.start) * self.sample_rate))
-            seg_len_in_secs = eou_time[i] - sou_time[i]
-            seg_len = self._audio_len_to_frame_len(int(seg_len_in_secs * self.sample_rate))
-            eou_targets[sou_idx : sou_idx + seg_len] = SPEECH_LABEL
-            last_idx = min(sou_idx + seg_len - 1, hidden_length - 1)
-            if is_backchannel[i] and not self.ignore_eob_label:
-                eou_targets[last_idx] = EOB_LABEL  # end of backchannel
-            else:
-                eou_targets[last_idx] = EOU_LABEL  # end of utterance
-
-        return eou_targets
-
-    def _get_text_tokens(self, cut: Cut):
-        """
-        Add EOU labels to the text and get the text tokens for a single audio segment.
-        Args:
-            cut: Cut object
-        Returns:
-            text_tokens: torch.Tensor of text tokens, shape [T]
-        """
-        if not cut.has_custom("sou_time") or not cut.has_custom("eou_time") or not cut.has_custom("utterances"):
-            # assume only single speech segment
-            utterances = [cut.supervisions[0].text]
-        else:
-            utterances = cut.custom["utterances"]
-
-        if not isinstance(utterances, list):
-            utterances = [utterances]
-
-        if cut.has_custom("is_backchannel"):
-            is_backchannel = cut.custom["is_backchannel"]
-            if not isinstance(is_backchannel, list):
-                is_backchannel = [is_backchannel]
-            assert len(utterances) == len(
-                is_backchannel
-            ), f"Number of utterances and backchannel do not match: utterance ({len(utterances)}) vs backchannel ({len(is_backchannel)})"
-        else:
-            is_backchannel = [False] * len(utterances)
-
-        total_text = ""
-        for i, text in enumerate(utterances):
-            if not text:
-                # skip empty utterances
-                continue
-            if self.add_eou_to_text:
-                eou_string = self.eob_string if is_backchannel[i] and not self.ignore_eob_label else self.eou_string
-                if self.add_sep_before_eou:
-                    eou_string = " " + eou_string
-            else:
-                eou_string = ""
-            total_text += text + eou_string + " "
-        total_text = total_text.strip()
-        return torch.as_tensor(self.tokenizer(total_text))
-
-    def _random_pad_audio(self, audio: torch.Tensor, audio_len: torch.Tensor, eou_targets: torch.Tensor):
-        """
-        Randomly pad the audio signal with non-speech signal before and after the audio signal.
-        Args:
-            audio: torch.Tensor of a single audio signal, shape [T]
-            audio_len: torch.Tensor of audio signal length, shape [1]
-            eou_targets: torch.Tensor of EOU labels, shape [T]
-        Returns:
-            padded_audio: torch.Tensor of padded audio signal, shape [T+padding]
-            padded_audio_len: torch.Tensor of padded audio signal length, shape [1]
-            padded_eou_targets: torch.Tensor of padded EOU labels, shape [T+padding]
-            padded_eou_targets_len: torch.Tensor of padded EOU label length, shape [1]
-        """
-        p = np.random.rand()
-        if self.padding_cfg is None or p > self.padding_cfg.prob:
-            # don't apply padding
-            eou_targets = self._repeat_eou_labels(eou_targets)
-            return audio, audio_len, eou_targets
-
-        duration = audio_len.item() / self.cfg.sample_rate
-        # if already longer than the maximum duration, return the original audio
-        if duration >= self.padding_cfg.max_total_duration:
-            return audio, audio_len, eou_targets
-
-        # apply padding
-        audio = audio[:audio_len]
-
-        self.padding_cfg.min_pre_pad_duration = max(
-            self.padding_cfg.min_pre_pad_duration, self.padding_cfg.min_pad_duration
-        )
-        self.padding_cfg.min_post_pad_duration = max(
-            self.padding_cfg.min_post_pad_duration, self.padding_cfg.min_pad_duration
-        )
-
-        max_padding_duration = max(0, self.padding_cfg.max_total_duration - duration)
-        if max_padding_duration <= self.padding_cfg.min_pre_pad_duration + self.padding_cfg.min_post_pad_duration:
-            min_padding_duration = 0
-        else:
-            min_padding_duration = self.padding_cfg.min_pre_pad_duration + self.padding_cfg.min_post_pad_duration
-
-        pre_padding_duration = None
-        post_padding_duration = None
-
-        if self.padding_cfg.pad_distribution == 'uniform':
-            total_padding_duration = np.random.uniform(min_padding_duration, max_padding_duration)
-        elif self.padding_cfg.pad_distribution == 'normal':
-            total_padding_duration = np.random.normal(self.padding_cfg.normal_mean, self.padding_cfg.normal_std)
-            total_padding_duration = max(min_padding_duration, min(max_padding_duration, total_padding_duration))
-        elif self.padding_cfg.pad_distribution == 'constant':
-            pass
-        else:
-            raise ValueError(f"Unknown padding distribution: {self.padding_cfg.pad_distribution}")
-
-        if self.padding_cfg.pad_distribution == 'constant':
-            pre_padding_duration = self.padding_cfg.pre_pad_duration
-            post_padding_duration = self.padding_cfg.post_pad_duration
-        elif min_padding_duration == 0:
-            pre_padding_duration = total_padding_duration / 2
-            post_padding_duration = total_padding_duration / 2
-        else:
-            post_padding_duration = np.random.uniform(
-                self.padding_cfg.min_post_pad_duration, total_padding_duration - self.padding_cfg.min_pre_pad_duration
-            )
-            pre_padding_duration = total_padding_duration - post_padding_duration
-
-        if self.padding_cfg.max_pad_duration is not None:
-            pre_padding_duration = min(pre_padding_duration, self.padding_cfg.max_pad_duration)
-            post_padding_duration = min(post_padding_duration, self.padding_cfg.max_pad_duration)
-
-        pre_padding_len = math.ceil(pre_padding_duration * self.cfg.sample_rate)
-        post_padding_len = math.ceil(post_padding_duration * self.cfg.sample_rate)
-
-        # pad the audio signal
-        pre_padding = torch.zeros(pre_padding_len, dtype=audio.dtype)
-        post_padding = torch.zeros(post_padding_len, dtype=audio.dtype)
-        padded_audio = torch.cat((pre_padding, audio, post_padding), dim=0)
-        padded_audio_len = audio_len + pre_padding_len + post_padding_len
-
-        # pad the EOU labels
-        pre_padding_eou_len = self._audio_len_to_frame_len(pre_padding_len)
-        post_padding_eou_len = self._audio_len_to_frame_len(post_padding_len)
-        pre_padding_eou = torch.zeros(pre_padding_eou_len, dtype=eou_targets.dtype)
-        post_padding_eou = torch.zeros(post_padding_eou_len, dtype=eou_targets.dtype)
-        padded_eou_targets = torch.cat((pre_padding_eou, eou_targets, post_padding_eou), dim=0)
-        padded_eou_targets = self._repeat_eou_labels(padded_eou_targets)
-        return padded_audio, padded_audio_len, padded_eou_targets
-
-    def _maybe_augment_audio(self, audio: torch.Tensor, audio_len: torch.Tensor):
-        """
-        Apply augmentation to the audio signal if augmentor is provided.
-        Args:
-            audio: torch.Tensor of a single audio signal, shape [T]
-            audio_len: torch.Tensor of audio signal length, shape [1]
-        Returns:
-            augmented_audio: torch.Tensor of augmented audio signal, shape [T]
-            augmented_audio_len: torch.Tensor of augmented audio signal length, shape [1]
-        """
-        if self.augmentor is None:
-            return audio, audio_len
-
-        # Cast to AudioSegment
-        audio_segment = AudioSegment(
-            samples=audio[:audio_len].numpy(),
-            sample_rate=self.sample_rate,
-            offset=0,
-            duration=audio_len.item() / self.sample_rate,
-        )
-        # Apply augmentation
-        self.augmentor.perturb(audio_segment)
-        audio = torch.from_numpy(audio_segment.samples).float()
-        audio_len = audio.size(0)
-
-        return audio, audio_len

nemo/collections/asr/data/audio_to_label.py

@@ -1,1422 +0,0 @@
-# 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
-
-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 import webdataset as wds
-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

@@ -1,304 +0,0 @@
-# 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

@@ -1,1389 +0,0 @@
-# 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
-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 import webdataset as wds
-from nemo.utils.data_utils import DataStoreObject, datastore_object_get, is_datastore_cache_shared, is_datastore_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))
-
-    # 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:
-                    offset_list = self.collection.mapping[self.current_fn]
-                    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

@@ -1,777 +0,0 @@
-# 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

@@ -1,997 +0,0 @@
-# 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 numpy as np
-import torch
-from lightning.pytorch import LightningModule
-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 AudioAugmentor, process_augmentations
-from nemo.collections.common.data.dataset import CodeSwitchedDataset, ConcatDataset
-from nemo.collections.common.tokenizers import TokenizerSpec
-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("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("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("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("dataset does not have explicitly defined labels")
-
-    if 'max_utts' in config:
-        logging.warning('"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, hypotheses 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"] = hypotheses.text
-
-            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"] = hypotheses.text
-
-            if hasattr(hypotheses, "timestamp") and isinstance(hypotheses.timestamp, dict):
-                for timestamp_type, timestamps in hypotheses.timestamp.items():
-                    if timestamp_type in ['char', 'word', 'segment']:
-                        item[f'{timestamp_type}_timestamps'] = [
-                            {
-                                key: int(value) if isinstance(value, np.int64) else value
-                                for key, value in offset.items()
-                            }
-                            for offset in timestamps
-                        ]
-
-            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