Update app.py

app.py

@@ -1,183 +1,97 @@
 import gradio as gr
-import nemo.collections.asr as nemo_asr
 import numpy as np
-from pydub import AudioSegment
-from pydub.silence import detect_silence
-import warnings
-import torch
-import logging
-import io
+import sherpa_onnx
+import time
 import os
-import datetime
-
-warnings.filterwarnings("ignore")
+import urllib.request
+import tarfile
+
+# Download and extract model if not present
+model_dir = "sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8"
+if not os.path.exists(model_dir):
+    url = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2"
+    urllib.request.urlretrieve(url, "model.tar.bz2")
+    with tarfile.open("model.tar.bz2") as tar:
+        tar.extractall()
+    os.remove("model.tar.bz2")
+
+# Configure endpoint detection for natural pauses
+endpoint_config = sherpa_onnx.EndpointConfig(
+    rule1_min_trailing_silence=1.0,  # Activate on 1s silence
+    rule2_min_trailing_silence=0.5,  # After speech, 0.5s silence
+    rule3_min_utterance_length=30.0  # Max 30s utterance
+)
 
-# Setup file-based logging for persistence
-LOG_FILE = "/tmp/app_logs.txt"
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler(LOG_FILE, mode='a'),
-        logging.StreamHandler()  # Also to console for HF logs
-    ]
+# Create OnlineRecognizer
+config = sherpa_onnx.OnlineRecognizerConfig(
+    feat_config=sherpa_onnx.FeatureConfig(sample_rate=16000),
+    model_config=sherpa_onnx.OnlineTransducerModelConfig(
+        encoder=os.path.join(model_dir, "encoder.int8.onnx"),
+        decoder=os.path.join(model_dir, "decoder.int8.onnx"),
+        joiner=os.path.join(model_dir, "joiner.int8.onnx")
+    ),
+    tokens=os.path.join(model_dir, "tokens.txt"),
+    provider="cpu",
+    num_threads=2,  # Match HF free-tier cores
+    endpoint_config=endpoint_config
 )
-logger = logging.getLogger(__name__)
+recognizer = sherpa_onnx.OnlineRecognizer(config)
+
+def transcribe(state, audio_chunk):
+    if state is None:
+        state = {
+            "stream": recognizer.create_stream(),
+            "transcript": "",
+            "current_partial": "",
+            "log": "",
+            "last_time": time.time()
+        }
 
-def append_log(message):
-    """Append log message to file and return updated log content."""
-    logger.info(message)
     try:
-        with open(LOG_FILE, 'r') as f:
-            logs = f.read()
-    except FileNotFoundError:
-        logs = ""
-    return logs
-
-# Global model loader
-model = None
-
-def load_model():
-    global model
-    if model is None:
-        logger.info("Loading Parakeet v3 model...")
-        model = nemo_asr.models.ASRModel.from_pretrained(
-            model_name="nvidia/parakeet-tdt-0.6b-v3",
-            map_location="cpu"
-        )
-        model.eval()
-        logger.info("Model loaded successfully.")
-    return model
-
-class TranscriptionState:
-    def __init__(self):
-        self.buffer = None  # AudioSegment
-        self.text = ""
+        sr, y = audio_chunk
+        if y.ndim > 1:
+            y = np.mean(y, axis=1)
+        y = y.astype(np.float32)
+        if np.max(np.abs(y)) > 0:
+            y /= np.max(np.abs(y))  # Normalize to [-1, 1]
+        else:
+            state["log"] += "Weak signal detected.\n"
+            return state, state["transcript"] + state["current_partial"], state["log"]
+
+        state["stream"].accept_waveform(sr, y)
+
+        while recognizer.is_ready(state["stream"]):
+            recognizer.decode_stream(state["stream"])
+
+        result = recognizer.get_result(state["stream"])
+        current_text = result.text.strip()
+
+        if current_text != state["current_partial"]:
+            state["current_partial"] = current_text
+            latency = time.time() - state["last_time"]
+            state["log"] += f"Partial update (latency: {latency:.2f}s): {current_text}\n"
+            state["last_time"] = time.time()
+
+        if recognizer.is_endpoint(state["stream"]):
+            if current_text:
+                state["transcript"] += current_text + " "
+                state["log"] += f"Endpoint detected, committed: {current_text}\n"
+            recognizer.reset(state["stream"])
+            state["current_partial"] = ""
 
-def transcribe_segment(segment_array: np.ndarray):
-    """Transcribe a normalized audio segment."""
-    load_model()
-    logger.info(f"Transcribing segment of length {len(segment_array)} samples.")
-    with torch.no_grad(), warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        output = model.transcribe([segment_array])
-    logger.info(f"Transcription complete: '{output[0][:50]}...'")
-    return output[0]
-
-def process_live_audio(chunk_bytes, state: TranscriptionState):
-    """Process live mic PCM bytes chunk with VAD and buffer management."""
-    if chunk_bytes is None or len(chunk_bytes) == 0:
-        logger.debug("Empty chunk received.")
-        return state.text, state, append_log("Empty chunk skipped.")
-
-    chunk_size = len(chunk_bytes)
-    logger.debug(f"Received chunk of {chunk_size} bytes.")
-
-    # Create AudioSegment from raw PCM bytes (16kHz mono int16)
-    try:
-        new_segment = AudioSegment(
-            data=chunk_bytes,
-            frame_rate=16000,
-            sample_width=2,
-            channels=1
-        )
     except Exception as e:
-        logger.error(f"Chunk creation error: {e}")
-        return state.text, state, append_log(f"Chunk error: {e}")
-
-    # Append to buffer
-    if state.buffer is None:
-        state.buffer = new_segment
-        logger.debug("Initialized new buffer.")
-    else:
-        state.buffer += new_segment
-
-    buffer_dur = state.buffer.duration_seconds
-    logger.debug(f"Buffer duration: {buffer_dur:.1f}s")
-
-    # Trim buffer to prevent accumulation (keep last 60s)
-    if buffer_dur > 60:
-        logger.info("Buffer exceeded 60s; trimming and re-transcribing.")
-        full_array = np.array(state.buffer.get_array_of_samples(), dtype=np.float32) / 32768.0
-        state.text = transcribe_segment(full_array)
-        state.buffer = state.buffer[-30000:]
-        return state.text, state, append_log("Buffer trimmed at 60s.")
-
-    # VAD: Detect pauses in current buffer
-    silent_windows = detect_silence(
-        state.buffer,
-        min_silence_len=500,  # 0.5s pause
-        silence_thresh=-40    # dB threshold
-    )
-
-    if len(silent_windows) > 0:
-        last_silence_end = silent_windows[-1][1]
-        if last_silence_end < len(state.buffer):
-            logger.info(f"VAD detected pause at {last_silence_end}ms; transcribing up to pause.")
-            segment = state.buffer[:last_silence_end]
-            segment_array = np.array(segment.get_array_of_samples(), dtype=np.float32) / 32768.0
-            partial_text = transcribe_segment(segment_array)
-            state.text = partial_text
-            state.buffer = state.buffer[last_silence_end:]
-            return state.text, state, append_log(f"VAD update: Pause detected, transcribed '{partial_text[:50]}...'")
-
-    return state.text, state, append_log(f"Chunk appended; buffer at {buffer_dur:.1f}s, awaiting pause.")
-
-def clear_session(state: TranscriptionState):
-    """Reset session."""
-    state.buffer = None
-    state.text = ""
-    logger.info("Session cleared by user.")
-    return "", state, append_log("Session cleared.")
-
-# Gradio UI (mic-only)
-with gr.Blocks(title="Parakeet v3 Real-Time Mic Transcription") as demo:
-    gr.Markdown(
-        """
-        # NVIDIA Parakeet-TDT 0.6B v3 Real-Time Transcription
-        Speak continuously into the microphone—transcription updates live on natural pauses (0.5s+). Supports 25 European languages automatically. Optimized for CPU.
-        """
-    )
+        state["log"] += f"Error: {str(e)}\n"
 
-    state = gr.State(TranscriptionState())
-    audio_input = gr.Audio(
-        sources=["microphone"],
-        type="bytes",
-        streaming=True,
-        label="Speak now—updates on pauses",
-        waveform_options={"show_recording_waveform": True}
-    )
-    output_text = gr.Textbox(
-        label="Live Transcription",
-        lines=10,
-        interactive=False
-    )
-    log_text = gr.Textbox(
-        label="Debug Logs (Persistent)",
-        lines=15,
-        interactive=False,
-        show_copy_button=True
-    )
-    clear_btn = gr.Button("Clear Session", variant="secondary")
+    return state, state["transcript"] + state["current_partial"], state["log"]
 
-    # Stream updates on each chunk
-    audio_input.change(
-        process_live_audio,
-        inputs=[audio_input, state],
-        outputs=[output_text, state, log_text],
-        show_progress="minimal"
-    )
-    clear_btn.click(
-        clear_session,
-        inputs=state,
-        outputs=[output_text, state, log_text]
-    )
+with gr.Blocks() as demo:
+    gr.Markdown("# Real-Time Multilingual Microphone Transcription")
+    with gr.Row():
+        audio = gr.Audio(source="microphone", type="numpy", streaming=True, label="Speak here")
+    transcript = gr.Textbox(label="Transcription", interactive=False)
+    logs = gr.Textbox(label="Debug Logs", interactive=False, lines=5)
+    state = gr.State()
 
-    gr.Markdown(
-        """
-        **Tips:** Speak clearly with brief pauses for instant updates. Long monologues auto-update every 60s. Logs show real-time debug info.
-        """
-    )
+    audio.stream(transcribe, [state, audio], [state, transcript, logs])
 
-if __name__ == "__main__":
-    demo.launch(share=False, debug=True)
+demo.launch()