Update app.py

app.py

@@ -2,111 +2,103 @@ import gradio as gr
 import torch
 import librosa
 import numpy as np
-from transformers import WhisperProcessor, WhisperForConditionalGeneration
-
-# ------------------------------
-# 1. Load the Model & Processor
-# ------------------------------
-model_id = "ivrit-ai/faster-whisper-v2-d4"  # Replace with a verified HF model if needed, e.g. "openai/whisper-large-v2"
-
-try:
-    processor = WhisperProcessor.from_pretrained(model_id)
-    model = WhisperForConditionalGeneration.from_pretrained(model_id)
-except OSError as e:
-    raise ValueError(
-        f"Unable to load model or tokenizer from '{model_id}'. "
-        "Double-check that the model ID is valid on Hugging Face Hub."
-    ) from e
-
-# Force GPU usage if available
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model.to(device)
-
-# ---------------------------
-# 2. Global Stop Flag
-# ---------------------------
+from faster_whisper import WhisperModel
+
+# -----------------------------
+# 1. Load Faster Whisper Model
+# -----------------------------
+#   * Use device="cuda" if a GPU is available, otherwise "cpu".
+model = WhisperModel(
+    "ivrit-ai/whisper-large-v3-turbo-ct2",
+    device="cuda" if torch.cuda.is_available() else "cpu"
+)
+
+# --------------------------------
+# 2. Global Stop Flag for Gradio
+# --------------------------------
 stop_processing = False
 
 def stop():
-    """
-    Callback to set a global stop flag, allowing the user to interrupt
-    transcription mid-way through processing.
-    """
+    """Set a global stop flag, letting the user interrupt transcription."""
     global stop_processing
     stop_processing = True
 
-
-# -------------------------------------------
+# --------------------------------------------
 # 3. Transcription Function (with Chunking)
-# -------------------------------------------
-def transcribe(audio):
+# --------------------------------------------
+def transcribe(audio_file):
     """
-    Transcribes Hebrew speech from an uploaded audio file.
-    Splits long audio into 2-minute chunks to handle large files (up to 60 min).
+    Transcribe Hebrew speech from an uploaded audio file using Faster Whisper.
+    Splits audio into ~2-minute chunks to handle very large files (up to 60 min).
     """
     global stop_processing
-    stop_processing = False  # Reset at start
+    stop_processing = False  # Reset at the start of a new transcription
+
+    # A) Load Audio (Librosa) -> 16kHz
+    sample_rate = 16000
+    waveform, sr = librosa.load(audio_file, sr=sample_rate)
 
-    # --- A) Load Audio & Limit to 60 Minutes
-    waveform, sr = librosa.load(audio, sr=16000)
+    # Trim audio if it exceeds 60 minutes
     max_audio_length = 60 * 60  # 60 minutes in seconds
     if len(waveform) > sr * max_audio_length:
         waveform = waveform[: sr * max_audio_length]
 
-    # --- B) Split Audio into ~2-minute Chunks
-    chunk_duration = 2 * 60  # 2 minutes (120 seconds)
+    # B) Split into ~2-min chunks
+    chunk_duration = 2 * 60  # 2 minutes = 120 seconds
     chunks = []
-    for i in range(0, len(waveform), sr * chunk_duration):
+    for start_idx in range(0, len(waveform), sr * chunk_duration):
         if stop_processing:
             return "⚠️ Transcription Stopped by User ⚠️"
 
-        chunk = waveform[i : i + sr * chunk_duration]
-        # Optional: skip very short chunks (<2 seconds)
+        chunk = waveform[start_idx : start_idx + sr * chunk_duration]
+        # Skip very short chunks (<2s) if you want
         if len(chunk) < sr * 2:
             continue
         chunks.append(chunk)
 
-    # --- C) Process Each Chunk with Whisper
-    transcriptions = []
+    # C) Transcribe Each Chunk with Faster Whisper
+    all_texts = []
     for chunk in chunks:
         if stop_processing:
             return "⚠️ Transcription Stopped by User ⚠️"
 
-        # Convert the chunk to Whisper input features
-        inputs = processor(chunk, sampling_rate=16000, return_tensors="pt", language="he").input_features.to(device)
-
-        with torch.no_grad():
-            predicted_ids = model.generate(
-                inputs,
-                max_new_tokens=444,   # Prevent exceeding model’s token limit
-                do_sample=False,      # Stable transcription (disable random sampling)
-            )
+        # Faster Whisper can accept a numpy array directly (float32)
+        # Provide `sample_rate` and `language="he"` for Hebrew
+        segment_generator, info = model.transcribe(
+            chunk.astype(np.float32), 
+            language="he", 
+            sample_rate=sample_rate
+        )
 
-        # Decode tokens to text
-        text = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-        transcriptions.append(text)
+        # Gather text from each segment
+        chunk_text = []
+        for seg in segment_generator:
+            if stop_processing:
+                return "⚠️ Transcription Stopped by User ⚠️"
+            chunk_text.append(seg.text)
 
-    # --- D) Combine All Chunk Transcriptions
-    return " ".join(transcriptions)
+        # Combine chunk texts
+        all_texts.append(" ".join(chunk_text))
 
+    # Join all chunk transcriptions into one final string
+    full_text = " ".join(all_texts)
+    return full_text
 
-# ------------------------
+# ---------------------------
 # 4. Build Gradio Interface
-# ------------------------
-with gr.Blocks() as iface:
+# ---------------------------
+with gr.Blocks() as demo:
     gr.Markdown("## Hebrew Speech-to-Text (Faster Whisper)")
 
-    # Inputs/Outputs
     audio_input = gr.Audio(type="filepath", label="Upload Hebrew Audio")
-    output_text = gr.Textbox(label="Transcription Output")
+    transcription_output = gr.Textbox(label="Transcription Output")
 
-    # Buttons
     start_btn = gr.Button("Start Transcription")
     stop_btn = gr.Button("Stop Processing", variant="stop")
 
-    # Click Actions
-    start_btn.click(transcribe, inputs=audio_input, outputs=output_text)
+    # Link buttons to functions
+    start_btn.click(transcribe, inputs=audio_input, outputs=transcription_output)
     stop_btn.click(stop)
 
-# Launch the Gradio App
-iface.launch()
+# Launch the Gradio app
+demo.launch()