Download server_aware_streaming.py from echodict/NeMo: direct link, hf CLI and curl.
- Browser
- Download file 36.2 kB
-
https://huggingface.co/datasets/echodict/NeMo/resolve/main/server_aware_streaming.py
- Command line
-
hf download hf://datasets/echodict/NeMo/server_aware_streaming.py
-
curl -L -o server_aware_streaming.py https://huggingface.co/datasets/echodict/NeMo/resolve/main/server_aware_streaming.py
36.2 kB
| """WebSocket ASR server for Nemotron-Speech with true incremental streaming and timestamps.""" | |
| import asyncio | |
| import argparse | |
| import hashlib | |
| import json | |
| import os | |
| from dataclasses import dataclass, field | |
| from typing import Any, Optional, Tuple | |
| import numpy as np | |
| import torch | |
| from aiohttp import web, WSMsgType | |
| from loguru import logger | |
| from nemo.collections.asr.parts.utils.transcribe_utils import normalize_timestamp_output | |
| from nemo.collections.asr.parts.utils.timestamp_utils import process_timestamp_outputs | |
| # Enable debug logging with DEBUG_ASR=1 | |
| DEBUG_ASR = os.environ.get("DEBUG_ASR", "0") == "1" | |
| def _hash_audio(audio: np.ndarray) -> str: | |
| """Get short hash of audio array for debugging.""" | |
| if audio is None or len(audio) == 0: | |
| return "empty" | |
| return hashlib.md5(audio.tobytes()).hexdigest()[:8] | |
| # DEFAULT_MODEL = "./nemotron-speech-streaming-en-0.6b/nemotron-speech-streaming-en-0.6b.nemo" | |
| # DEFAULT_MODEL = "results/NeMo_Ja_FastConformer_Streaming/checkpoints/NeMo_Ja_FastConformer_Streaming.nemo" | |
| DEFAULT_MODEL = "results/NeMo_Ja_FastConformer_Transducer_RNNT_EOU/checkpoints/NeMo_Ja_FastConformer_Transducer_RNNT_EOU.nemo" | |
| # Right context options for att_context_size=[70, X] | |
| RIGHT_CONTEXT_OPTIONS = { | |
| 0: "~80ms ultra-low latency", | |
| 1: "~160ms low latency (recommended)", | |
| 6: "~560ms balanced", | |
| 13: "~1.12s highest accuracy", | |
| } | |
| class ASRSession: | |
| """Per-connection session state with caches for true incremental streaming.""" | |
| id: str | |
| websocket: Any | |
| # Accumulated audio buffer (all audio received so far) | |
| accumulated_audio: Optional[np.ndarray] = None | |
| # Number of mel frames already emitted to encoder | |
| emitted_frames: int = 0 | |
| # Encoder cache state | |
| cache_last_channel: Optional[torch.Tensor] = None | |
| cache_last_time: Optional[torch.Tensor] = None | |
| cache_last_channel_len: Optional[torch.Tensor] = None | |
| # Decoder state | |
| previous_hypotheses: Any = None | |
| pred_out_stream: Any = None | |
| # Current transcription (model's cumulative output) | |
| current_text: str = "" | |
| # Current timestamps | |
| current_timestamps: Optional[dict] = None | |
| # Last text emitted to client on hard reset (for server-side deduplication) | |
| # We only send the delta (new portion) to avoid downstream duplication | |
| last_emitted_text: str = "" | |
| # Audio overlap buffer for mid-utterance reset continuity | |
| # This preserves the last N ms of audio to provide encoder left-context | |
| # when a new segment starts after a reset | |
| overlap_buffer: Optional[np.ndarray] = None | |
| class ASRServer: | |
| """WebSocket server for streaming ASR with true incremental processing.""" | |
| def __init__( | |
| self, | |
| model: str, | |
| host: str = "0.0.0.0", | |
| port: int = 8080, | |
| right_context: int = 1, | |
| ): | |
| self.model_name_or_path = model | |
| self.host = host | |
| self.port = port | |
| self.right_context = right_context | |
| self.model = None | |
| self.sample_rate = 16000 | |
| # Inference lock | |
| self.inference_lock = asyncio.Lock() | |
| # Active sessions | |
| self.sessions: dict[str, ASRSession] = {} | |
| # Model loaded flag for health check | |
| self.model_loaded = False | |
| # Streaming parameters (calculated from model config) | |
| self.shift_frames = None | |
| self.pre_encode_cache_size = None | |
| self.hop_samples = None | |
| # Audio overlap for mid-utterance reset continuity (calculated in load_model) | |
| self.overlap_samples = None | |
| def load_model(self): | |
| """Load the NeMo ASR model with streaming configuration.""" | |
| import nemo.collections.asr as nemo_asr | |
| from omegaconf import OmegaConf | |
| # Detect if model is a local .nemo file or HuggingFace model name | |
| is_local_file = ( | |
| self.model_name_or_path.endswith('.nemo') or | |
| os.path.exists(self.model_name_or_path) | |
| ) | |
| if is_local_file: | |
| logger.info(f"Loading model from local file: {self.model_name_or_path}") | |
| self.model = nemo_asr.models.ASRModel.restore_from( | |
| self.model_name_or_path, map_location='cpu' | |
| ) | |
| else: | |
| logger.info(f"Loading model from HuggingFace: {self.model_name_or_path}") | |
| self.model = nemo_asr.models.ASRModel.from_pretrained( | |
| self.model_name_or_path, map_location='cpu' | |
| ) | |
| self.model = self.model.cuda() | |
| # Configure attention context for streaming | |
| logger.info(f"Setting att_context_size=[70, {self.right_context}] ({RIGHT_CONTEXT_OPTIONS.get(self.right_context, 'custom')})") | |
| if hasattr(self.model.encoder, "set_default_att_context_size"): | |
| self.model.encoder.set_default_att_context_size([70, self.right_context]) | |
| # Configure greedy decoding (required for Blackwell GPU) | |
| logger.info("Configuring greedy decoding for Blackwell compatibility and enabling timestamps...") | |
| # Check model type to set preserve_alignments | |
| preserve_alignments = False | |
| if hasattr(self.model, 'joint'): # RNNT model | |
| preserve_alignments = True | |
| decoding_cfg_dict = { | |
| 'strategy': 'greedy', | |
| 'greedy': { | |
| 'max_symbols': 10, | |
| 'loop_labels': False, | |
| 'use_cuda_graph_decoder': False, | |
| }, | |
| 'compute_timestamps': True | |
| } | |
| if preserve_alignments: | |
| decoding_cfg_dict['preserve_alignments'] = True | |
| self.model.change_decoding_strategy( | |
| decoding_cfg=OmegaConf.create(decoding_cfg_dict) | |
| ) | |
| # Force enable timestamps | |
| if hasattr(self.model, 'decoding'): | |
| if hasattr(self.model.decoding, 'compute_timestamps'): | |
| self.model.decoding.compute_timestamps = True | |
| if hasattr(self.model.decoding, 'preserve_alignments'): | |
| self.model.decoding.preserve_alignments = preserve_alignments | |
| if hasattr(self.model.decoding, 'ctc_decoder') and hasattr(self.model.decoding.ctc_decoder, 'compute_timestamps'): | |
| self.model.decoding.ctc_decoder.compute_timestamps = True | |
| self.model.decoding.ctc_decoder.return_hypotheses = True | |
| # Force RNNT decoder settings if present | |
| if hasattr(self.model, 'joint'): | |
| if hasattr(self.model.decoding, 'rnnt_decoder_predictions_tensor'): | |
| if hasattr(self.model.decoding, 'compute_timestamps'): | |
| # We MUST set this to False during the stream step, | |
| # otherwise the internal `rnnt_decoder_predictions_tensor` will try to compute | |
| # timestamps on partial chunks and fail with length mismatch ValueError. | |
| # We will manually compute the timestamps later in `_process_chunk` / `_process_final_chunk` | |
| self.model.decoding.compute_timestamps = False | |
| if hasattr(self.model.decoding, 'preserve_alignments'): | |
| self.model.decoding.preserve_alignments = True | |
| if hasattr(self.model.decoding, 'return_hypotheses'): | |
| self.model.decoding.return_hypotheses = True | |
| self.model.eval() | |
| # Disable dither for deterministic preprocessing | |
| self.model.preprocessor.featurizer.dither = 0.0 | |
| # Get streaming config | |
| scfg = self.model.encoder.streaming_cfg | |
| logger.info(f"Streaming config: chunk_size={scfg.chunk_size}, shift_size={scfg.shift_size}") | |
| # Calculate parameters | |
| preprocessor_cfg = self.model.cfg.preprocessor | |
| hop_length_sec = preprocessor_cfg.get('window_stride', 0.01) | |
| self.hop_samples = int(hop_length_sec * self.sample_rate) | |
| # shift_size[1] = 16 frames for 160ms chunks | |
| self.shift_frames = scfg.shift_size[1] if isinstance(scfg.shift_size, list) else scfg.shift_size | |
| # pre_encode_cache_size[1] = 9 frames | |
| pre_cache = scfg.pre_encode_cache_size | |
| self.pre_encode_cache_size = pre_cache[1] if isinstance(pre_cache, list) else pre_cache | |
| # drop_extra_pre_encoded for non-first chunks | |
| self.drop_extra = scfg.drop_extra_pre_encoded | |
| # Calculate silence padding for final chunk: | |
| # - right_context chunks for encoder lookahead | |
| # - 1 additional chunk for decoder finalization | |
| # With right_context=1, this is (1+1)*160ms = 320ms | |
| self.final_padding_frames = (self.right_context + 1) * self.shift_frames | |
| padding_ms = self.final_padding_frames * hop_length_sec * 1000 | |
| # Calculate audio overlap for mid-utterance reset continuity | |
| # Use pre_encode_cache_size frames = 90ms of left-context | |
| # This allows the encoder to have proper context when starting a new segment | |
| self.overlap_samples = self.pre_encode_cache_size * self.hop_samples | |
| overlap_ms = self.overlap_samples * 1000 / self.sample_rate | |
| shift_ms = self.shift_frames * hop_length_sec * 1000 | |
| logger.info(f"Model loaded: {type(self.model).__name__}") | |
| logger.info(f"Shift size: {shift_ms:.0f}ms ({self.shift_frames} frames)") | |
| logger.info(f"Pre-encode cache: {self.pre_encode_cache_size} frames") | |
| logger.info(f"Final chunk padding: {padding_ms:.0f}ms ({self.final_padding_frames} frames)") | |
| logger.info(f"Audio overlap for resets: {overlap_ms:.0f}ms ({self.overlap_samples} samples)") | |
| # Warmup inference to ensure model is fully loaded on GPU | |
| # This prevents GPU memory issues when LLM starts later | |
| self._warmup() | |
| def _warmup(self): | |
| """Run warmup inference using streaming API to claim GPU memory.""" | |
| import time | |
| logger.info("Running warmup inference (streaming API) to claim GPU memory...") | |
| start = time.perf_counter() | |
| # Generate 1 second of silence plus padding for warmup | |
| warmup_samples = self.sample_rate + (self.final_padding_frames * self.hop_samples) | |
| warmup_audio = np.zeros(warmup_samples, dtype=np.float32) | |
| # Run streaming inference to force all CUDA kernels to compile | |
| with torch.inference_mode(): | |
| audio_tensor = torch.from_numpy(warmup_audio).unsqueeze(0).cuda() | |
| audio_len = torch.tensor([len(warmup_audio)], device='cuda') | |
| # Preprocess | |
| mel, mel_len = self.model.preprocessor(input_signal=audio_tensor, length=audio_len) | |
| # Get initial cache | |
| cache = self.model.encoder.get_initial_cache_state(batch_size=1) | |
| # Run streaming step (processes entire mel as one chunk) | |
| _ = self.model.conformer_stream_step( | |
| processed_signal=mel, | |
| processed_signal_length=mel_len, | |
| cache_last_channel=cache[0], | |
| cache_last_time=cache[1], | |
| cache_last_channel_len=cache[2], | |
| keep_all_outputs=True, | |
| previous_hypotheses=None, | |
| previous_pred_out=None, | |
| drop_extra_pre_encoded=0, | |
| return_transcription=True, | |
| ) | |
| elapsed = (time.perf_counter() - start) * 1000 | |
| logger.info(f"Warmup complete in {elapsed:.0f}ms - GPU memory claimed") | |
| def _init_session(self, session: ASRSession): | |
| """Initialize a fresh session.""" | |
| # Initialize encoder cache | |
| cache = self.model.encoder.get_initial_cache_state(batch_size=1) | |
| session.cache_last_channel = cache[0] | |
| session.cache_last_time = cache[1] | |
| session.cache_last_channel_len = cache[2] | |
| # Reset audio buffer and frame counter | |
| if session.overlap_buffer is not None and len(session.overlap_buffer) > 0: | |
| session.accumulated_audio = session.overlap_buffer.copy() | |
| overlap_ms = len(session.overlap_buffer) * 1000 / self.sample_rate | |
| logger.debug( | |
| f"Session {session.id}: prepending {len(session.overlap_buffer)} samples " | |
| f"({overlap_ms:.0f}ms) of overlap audio" | |
| ) | |
| session.overlap_buffer = None # Clear after use | |
| else: | |
| session.accumulated_audio = np.array([], dtype=np.float32) | |
| session.emitted_frames = 0 | |
| # Reset decoder state | |
| session.previous_hypotheses = None | |
| session.pred_out_stream = None | |
| session.current_text = "" | |
| session.current_timestamps = None | |
| async def websocket_handler(self, request: web.Request) -> web.WebSocketResponse: | |
| """Handle a WebSocket client connection.""" | |
| import uuid | |
| ws = web.WebSocketResponse(max_msg_size=10 * 1024 * 1024) | |
| await ws.prepare(request) | |
| session_id = str(uuid.uuid4())[:8] | |
| session = ASRSession(id=session_id, websocket=ws) | |
| self.sessions[session_id] = session | |
| logger.info(f"Client {session_id} connected") | |
| try: | |
| async with self.inference_lock: | |
| await asyncio.get_event_loop().run_in_executor( | |
| None, self._init_session, session | |
| ) | |
| await ws.send_str(json.dumps({"type": "ready"})) | |
| logger.debug(f"Client {session_id}: sent ready") | |
| async for msg in ws: | |
| if msg.type == WSMsgType.BINARY: | |
| await self._handle_audio(session, msg.data) | |
| elif msg.type == WSMsgType.TEXT: | |
| try: | |
| data = json.loads(msg.data) | |
| msg_type = data.get("type") | |
| if msg_type == "reset" or msg_type == "end": | |
| finalize = data.get("finalize", True) | |
| await self._reset_session(session, finalize=finalize) | |
| else: | |
| logger.warning(f"Client {session_id}: unknown message type: {msg_type}") | |
| except json.JSONDecodeError: | |
| logger.warning(f"Client {session_id}: invalid JSON") | |
| elif msg.type == WSMsgType.ERROR: | |
| logger.error(f"Client {session_id} WebSocket error: {ws.exception()}") | |
| break | |
| logger.info(f"Client {session_id} disconnected") | |
| except Exception as e: | |
| logger.error(f"Client {session_id} error: {e}") | |
| import traceback | |
| logger.error(traceback.format_exc()) | |
| try: | |
| await ws.send_str(json.dumps({ | |
| "type": "error", | |
| "message": str(e) | |
| })) | |
| except: | |
| pass | |
| finally: | |
| if session_id in self.sessions: | |
| del self.sessions[session_id] | |
| return ws | |
| async def _handle_audio(self, session: ASRSession, audio_bytes: bytes): | |
| """Accumulate audio and process when enough frames available.""" | |
| audio_np = np.frombuffer(audio_bytes, dtype=np.int16).astype(np.float32) / 32768.0 | |
| if DEBUG_ASR: | |
| chunk_hash = hashlib.md5(audio_bytes).hexdigest()[:8] | |
| logger.debug(f"Session {session.id}: recv chunk {len(audio_bytes)}B hash={chunk_hash}") | |
| session.accumulated_audio = np.concatenate([session.accumulated_audio, audio_np]) | |
| # Process if we have enough audio for new frames | |
| min_audio_for_chunk = (session.emitted_frames + self.shift_frames + 1) * self.hop_samples | |
| while len(session.accumulated_audio) >= min_audio_for_chunk: | |
| async with self.inference_lock: | |
| result = await asyncio.get_event_loop().run_in_executor( | |
| None, self._process_chunk, session | |
| ) | |
| if result is not None: | |
| text, timestamps = result | |
| if text is not None and text != session.current_text: | |
| session.current_text = text | |
| session.current_timestamps = timestamps | |
| logger.debug(f"Session {session.id} interim: {text[-50:] if len(text) > 50 else text}") | |
| formatted_timestamps = [] | |
| if timestamps: | |
| if isinstance(timestamps, dict): | |
| for key, val in timestamps.items(): | |
| if key != 'timestep': | |
| formatted_timestamps.append({key: normalize_timestamp_output(val)}) | |
| elif isinstance(timestamps, list): | |
| # It might be a list of dictionaries if returned directly from Hypothesis | |
| formatted_timestamps = timestamps | |
| await session.websocket.send_str(json.dumps({ | |
| "type": "transcript", | |
| "text": text, | |
| "timestamps": formatted_timestamps if formatted_timestamps else None, | |
| "is_final": False | |
| })) | |
| # Update minimum for next iteration | |
| min_audio_for_chunk = (session.emitted_frames + self.shift_frames + 1) * self.hop_samples | |
| def _decode_stream_output(self, session, pred_out_stream): | |
| """Manually decode model outputs to retrieve timestamps.""" | |
| # For RNNT models | |
| if hasattr(self.model, 'joint'): | |
| decoding = self.model.decoding | |
| transcribed_texts = [] | |
| for preds_idx, preds_concat in enumerate(pred_out_stream): | |
| # We need to reshape for RNNT decoder which expects [B, D] or [B, T, D] | |
| # preds_concat is usually [T, D] from streaming step | |
| if preds_concat.dim() == 2: | |
| preds_tensor = preds_concat.unsqueeze(0) # [1, T, D] | |
| else: | |
| preds_tensor = preds_concat | |
| encoded_len = torch.tensor([preds_tensor.size(1)], device=preds_tensor.device) | |
| # We must use decoding() directly instead of rnnt_decoder_predictions_tensor | |
| # so that hypothesis is correctly initialized with alignments before calling compute_rnnt_timestamps | |
| hypotheses_list = decoding( | |
| encoder_output=preds_tensor, | |
| encoded_lengths=encoded_len, | |
| partial_hypotheses=session.previous_hypotheses | |
| ) | |
| # decoding() returns a tuple where [0] is a list of hypotheses | |
| hypotheses_list = hypotheses_list[0] | |
| if isinstance(hypotheses_list[0], list): | |
| transcribed_texts.append(hypotheses_list[0][0]) | |
| else: | |
| transcribed_texts.append(hypotheses_list[0]) | |
| # For CTC models | |
| else: | |
| if hasattr(self.model, 'ctc_decoder'): | |
| decoding = self.model.ctc_decoding | |
| else: | |
| decoding = self.model.decoding | |
| transcribed_texts = [] | |
| for preds_idx, preds_concat in enumerate(pred_out_stream): | |
| encoded_len = torch.tensor([len(preds_concat)], device=preds_concat.device) | |
| decoded_out = decoding.ctc_decoder_predictions_tensor( | |
| decoder_outputs=preds_concat.unsqueeze(0), | |
| decoder_lengths=encoded_len, | |
| return_hypotheses=True, | |
| ) | |
| if isinstance(decoded_out[0], list): | |
| transcribed_texts.append(decoded_out[0][0]) | |
| else: | |
| transcribed_texts.append(decoded_out[0]) | |
| # process timestamps | |
| if hasattr(self.model.cfg, 'preprocessor'): | |
| window_stride = self.model.cfg.preprocessor.get('window_stride', 0.01) | |
| else: | |
| window_stride = 0.01 | |
| subsampling_factor = 1 | |
| if hasattr(self.model, 'encoder') and hasattr(self.model.encoder, 'subsampling_factor'): | |
| subsampling_factor = self.model.encoder.subsampling_factor | |
| elif hasattr(self.model, 'encoder') and hasattr(self.model.encoder, 'conv_subsampling_factor'): | |
| subsampling_factor = self.model.encoder.conv_subsampling_factor | |
| # RNNT model returns a tuple of lists containing hypotheses when using decoding() directly | |
| # We need to process the timestamps if they haven't been computed inside decoding() | |
| if hasattr(self.model, 'joint'): | |
| import copy | |
| timestamp_type = 'all' | |
| if hasattr(decoding, 'cfg'): | |
| timestamp_type = decoding.cfg.get('rnnt_timestamp_type', 'all') | |
| for i in range(len(transcribed_texts)): | |
| if hasattr(transcribed_texts[i], 'timestamp') and not transcribed_texts[i].timestamp: | |
| # Before computing timestamps, ensure the Hypothesis text contains the temporary storage | |
| # format required by `compute_rnnt_timestamps` | |
| if hasattr(transcribed_texts[i], 'y_sequence'): | |
| prediction = transcribed_texts[i].y_sequence | |
| if type(prediction) != list: | |
| prediction = prediction.tolist() | |
| # Remove any blank and possibly big blank tokens from prediction | |
| if decoding.big_blank_durations is not None and decoding.big_blank_durations != []: # multi-blank RNNT | |
| num_extra_outputs = len(decoding.big_blank_durations) | |
| prediction = [p for p in prediction if p < decoding.blank_id - num_extra_outputs] | |
| elif hasattr(decoding, '_is_tdt') and decoding._is_tdt: # TDT model. | |
| prediction = [p for p in prediction if p < decoding.blank_id] | |
| else: # standard RNN-T | |
| prediction = [p for p in prediction if p != decoding.blank_id] | |
| alignments = copy.deepcopy(transcribed_texts[i].alignments) | |
| token_repetitions = [1] * len(alignments) | |
| # Update hypothesis text to hold the tuple (prediction, alignments, token_repetitions) | |
| transcribed_texts[i].text = (prediction, alignments, token_repetitions) | |
| # Now compute the timestamps | |
| transcribed_texts[i] = decoding.compute_rnnt_timestamps(transcribed_texts[i], timestamp_type) | |
| process_timestamp_outputs(transcribed_texts, subsampling_factor=subsampling_factor, window_stride=window_stride) | |
| return transcribed_texts | |
| def _process_chunk(self, session: ASRSession) -> Optional[Tuple[str, Optional[dict]]]: | |
| """Process accumulated audio, extract new mel frames, run streaming inference.""" | |
| try: | |
| # Preprocess ALL accumulated audio | |
| audio_tensor = torch.from_numpy(session.accumulated_audio).unsqueeze(0).cuda() | |
| audio_len = torch.tensor([len(session.accumulated_audio)], device='cuda') | |
| with torch.inference_mode(): | |
| mel, mel_len = self.model.preprocessor( | |
| input_signal=audio_tensor, | |
| length=audio_len | |
| ) | |
| # Available frames (excluding last edge frame) | |
| available_frames = mel.shape[-1] - 1 | |
| new_frame_count = available_frames - session.emitted_frames | |
| if new_frame_count < self.shift_frames: | |
| return session.current_text, session.current_timestamps # Not enough new frames | |
| # Extract chunk with pre-encode cache | |
| if session.emitted_frames == 0: | |
| chunk_start = 0 | |
| chunk_end = self.shift_frames | |
| drop_extra = 0 | |
| else: | |
| chunk_start = session.emitted_frames - self.pre_encode_cache_size | |
| chunk_end = session.emitted_frames + self.shift_frames | |
| drop_extra = self.drop_extra | |
| chunk_mel = mel[:, :, chunk_start:chunk_end] | |
| chunk_len = torch.tensor([chunk_mel.shape[-1]], device='cuda') | |
| # Run streaming inference | |
| ( | |
| session.pred_out_stream, | |
| transcribed_texts, | |
| session.cache_last_channel, | |
| session.cache_last_time, | |
| session.cache_last_channel_len, | |
| session.previous_hypotheses, | |
| ) = self.model.conformer_stream_step( | |
| processed_signal=chunk_mel, | |
| processed_signal_length=chunk_len, | |
| cache_last_channel=session.cache_last_channel, | |
| cache_last_time=session.cache_last_time, | |
| cache_last_channel_len=session.cache_last_channel_len, | |
| keep_all_outputs=False, | |
| previous_hypotheses=session.previous_hypotheses, | |
| previous_pred_out=session.pred_out_stream, | |
| drop_extra_pre_encoded=drop_extra, | |
| return_transcription=True, | |
| ) | |
| # Update emitted frame count | |
| session.emitted_frames += self.shift_frames | |
| # For RNNT models, conformer_stream_step already returns the decoded hypotheses in `transcribed_texts` | |
| # (which is assigned to `best_hyp` inside the method). So we do not need to call _decode_stream_output manually. | |
| # For CTC models, if we want full hypotheses with timestamps, we still need to decode manually. | |
| if hasattr(self.model, 'joint'): | |
| # The hypotheses are directly returned in `transcribed_texts` | |
| pass | |
| else: | |
| transcribed_texts = self._decode_stream_output(session, session.pred_out_stream) | |
| if transcribed_texts and transcribed_texts[0]: | |
| hyp = transcribed_texts[0] | |
| text = hyp.text if hasattr(hyp, 'text') else str(hyp) | |
| timestamps = hyp.timestamp if hasattr(hyp, 'timestamp') else None | |
| return text, timestamps | |
| return session.current_text, session.current_timestamps | |
| except Exception as e: | |
| logger.error(f"Session {session.id} chunk processing error: {e}") | |
| import traceback | |
| logger.error(traceback.format_exc()) | |
| return None | |
| async def _reset_session(self, session: ASRSession, finalize: bool = True): | |
| """Handle reset with soft or hard finalization.""" | |
| import time | |
| # Log audio state at reset for diagnostics | |
| audio_samples = len(session.accumulated_audio) if session.accumulated_audio is not None else 0 | |
| audio_duration_ms = (audio_samples * 1000) // self.sample_rate | |
| logger.debug( | |
| f"Session {session.id} {'hard' if finalize else 'soft'} reset: " | |
| f"accumulated={audio_samples} samples ({audio_duration_ms}ms), " | |
| f"emitted={session.emitted_frames} frames" | |
| ) | |
| if not finalize: | |
| text = session.current_text | |
| timestamps = session.current_timestamps | |
| formatted_timestamps = [] | |
| if timestamps: | |
| if isinstance(timestamps, dict): | |
| for key, val in timestamps.items(): | |
| if key != 'timestep': | |
| formatted_timestamps.append({key: normalize_timestamp_output(val)}) | |
| elif isinstance(timestamps, list): | |
| formatted_timestamps = timestamps | |
| await session.websocket.send_str(json.dumps({ | |
| "type": "transcript", | |
| "text": text, | |
| "timestamps": formatted_timestamps if formatted_timestamps else None, | |
| "is_final": True, | |
| "finalize": False | |
| })) | |
| logger.debug(f"Session {session.id} soft reset: '{text[-50:] if len(text) > 50 else text}'") | |
| return | |
| # HARD RESET: Full finalization with padding | |
| original_audio_length = len(session.accumulated_audio) if session.accumulated_audio is not None else 0 | |
| if original_audio_length > 0: | |
| padding_samples = self.final_padding_frames * self.hop_samples | |
| silence_padding = np.zeros(padding_samples, dtype=np.float32) | |
| session.accumulated_audio = np.concatenate([session.accumulated_audio, silence_padding]) | |
| # Process all remaining audio with keep_all_outputs=True | |
| final_text = session.current_text | |
| final_timestamps = session.current_timestamps | |
| if session.accumulated_audio is not None and len(session.accumulated_audio) > 0: | |
| start_time = time.perf_counter() | |
| async with self.inference_lock: | |
| result = await asyncio.get_event_loop().run_in_executor( | |
| None, self._process_final_chunk, session | |
| ) | |
| if result is not None: | |
| final_text, final_timestamps = result | |
| session.current_text = final_text | |
| session.current_timestamps = final_timestamps | |
| elapsed_ms = (time.perf_counter() - start_time) * 1000 | |
| logger.debug(f"Session {session.id} final chunk processed in {elapsed_ms:.1f}ms: '{final_text[-50:] if len(final_text) > 50 else final_text}'") | |
| # Server-side deduplication: only send the delta (new portion) | |
| if final_text.startswith(session.last_emitted_text): | |
| delta_text = final_text[len(session.last_emitted_text):].lstrip() | |
| else: | |
| delta_text = final_text | |
| session.last_emitted_text = final_text | |
| formatted_timestamps = [] | |
| if final_timestamps: | |
| if isinstance(final_timestamps, dict): | |
| for key, val in final_timestamps.items(): | |
| if key != 'timestep': | |
| formatted_timestamps.append({key: normalize_timestamp_output(val)}) | |
| elif isinstance(final_timestamps, list): | |
| formatted_timestamps = final_timestamps | |
| # Send only the delta to client | |
| await session.websocket.send_str(json.dumps({ | |
| "type": "transcript", | |
| "text": delta_text, | |
| "timestamps": formatted_timestamps if formatted_timestamps else None, | |
| "is_final": True, | |
| "finalize": True | |
| })) | |
| session.last_emitted_text = "" | |
| session.overlap_buffer = None | |
| self._init_session(session) | |
| def _process_final_chunk(self, session: ASRSession) -> Optional[Tuple[str, Optional[dict]]]: | |
| """Process all remaining audio with keep_all_outputs=True.""" | |
| try: | |
| if len(session.accumulated_audio) == 0: | |
| return session.current_text, session.current_timestamps | |
| # Preprocess ALL accumulated audio | |
| audio_tensor = torch.from_numpy(session.accumulated_audio).unsqueeze(0).cuda() | |
| audio_len = torch.tensor([len(session.accumulated_audio)], device='cuda') | |
| with torch.inference_mode(): | |
| mel, mel_len = self.model.preprocessor( | |
| input_signal=audio_tensor, | |
| length=audio_len | |
| ) | |
| # For final chunk, use ALL remaining frames (including edge) | |
| total_mel_frames = mel.shape[-1] | |
| remaining_frames = total_mel_frames - session.emitted_frames | |
| if remaining_frames <= 0: | |
| return session.current_text, session.current_timestamps | |
| # Extract final chunk with pre-encode cache | |
| if session.emitted_frames == 0: | |
| chunk_start = 0 | |
| drop_extra = 0 | |
| else: | |
| chunk_start = session.emitted_frames - self.pre_encode_cache_size | |
| drop_extra = self.drop_extra | |
| chunk_mel = mel[:, :, chunk_start:] | |
| chunk_len = torch.tensor([chunk_mel.shape[-1]], device='cuda') | |
| ( | |
| session.pred_out_stream, | |
| transcribed_texts, | |
| session.cache_last_channel, | |
| session.cache_last_time, | |
| session.cache_last_channel_len, | |
| session.previous_hypotheses, | |
| ) = self.model.conformer_stream_step( | |
| processed_signal=chunk_mel, | |
| processed_signal_length=chunk_len, | |
| cache_last_channel=session.cache_last_channel, | |
| cache_last_time=session.cache_last_time, | |
| cache_last_channel_len=session.cache_last_channel_len, | |
| keep_all_outputs=True, # Final chunk - output all remaining | |
| previous_hypotheses=session.previous_hypotheses, | |
| previous_pred_out=session.pred_out_stream, | |
| drop_extra_pre_encoded=drop_extra, | |
| return_transcription=True, | |
| ) | |
| if hasattr(self.model, 'joint'): | |
| pass | |
| else: | |
| transcribed_texts = self._decode_stream_output(session, session.pred_out_stream) | |
| if transcribed_texts and transcribed_texts[0]: | |
| hyp = transcribed_texts[0] | |
| text = hyp.text if hasattr(hyp, 'text') else str(hyp) | |
| timestamps = hyp.timestamp if hasattr(hyp, 'timestamp') else None | |
| return text, timestamps | |
| return session.current_text, session.current_timestamps | |
| except Exception as e: | |
| logger.error(f"Session {session.id} final chunk error: {e}") | |
| import traceback | |
| logger.error(traceback.format_exc()) | |
| return None | |
| async def health_handler(self, request: web.Request) -> web.Response: | |
| """Health check endpoint.""" | |
| return web.json_response({ | |
| "status": "healthy" if self.model_loaded else "loading", | |
| "model_loaded": self.model_loaded, | |
| }) | |
| async def start(self): | |
| """Start the HTTP + WebSocket server.""" | |
| self.load_model() | |
| self.model_loaded = True | |
| logger.info(f"Starting streaming ASR server on ws://{self.host}:{self.port}") | |
| app = web.Application() | |
| app.router.add_get("/health", self.health_handler) | |
| app.router.add_get("/", self.websocket_handler) | |
| runner = web.AppRunner(app) | |
| await runner.setup() | |
| site = web.TCPSite(runner, self.host, self.port) | |
| await site.start() | |
| logger.info(f"ASR server listening on ws://{self.host}:{self.port}") | |
| logger.info(f"Health check available at http://{self.host}:{self.port}/health") | |
| await asyncio.Future() # Run forever | |
| def main(): | |
| parser = argparse.ArgumentParser(description="Nemotron Streaming ASR WebSocket Server") | |
| parser.add_argument("--host", default="0.0.0.0", help="Host to bind to") | |
| parser.add_argument("--port", type=int, default=8080, help="Port to bind to") | |
| parser.add_argument( | |
| "--model", | |
| default=DEFAULT_MODEL, | |
| help="HuggingFace model name or path to local .nemo file" | |
| ) | |
| parser.add_argument( | |
| "--right-context", | |
| type=int, | |
| default=1, | |
| choices=[0, 1, 6, 13], | |
| help="Right context frames: 0=80ms, 1=160ms, 6=560ms, 13=1.12s latency" | |
| ) | |
| args = parser.parse_args() | |
| server = ASRServer( | |
| model=args.model, | |
| host=args.host, | |
| port=args.port, | |
| right_context=args.right_context, | |
| ) | |
| asyncio.run(server.start()) | |
| if __name__ == "__main__": | |
| main() | |