Update app.py

app.py

@@ -13,6 +13,8 @@ import logging
 
 # Constants and Configuration
 SAMPLE_RATE = 16000
+CHUNK_SECONDS = 30  # Split audio into 30-second chunks
+CHUNK_SAMPLES = SAMPLE_RATE * CHUNK_SECONDS
 MODEL_NAME = "openpecha/general_stt_base_model"
 
 title = "# Tibetan Speech-to-Text with Subtitles"
@@ -20,7 +22,7 @@ title = "# Tibetan Speech-to-Text with Subtitles"
 description = """
 This application transcribes Tibetan audio files and generates subtitles using:
 - Wav2Vec2 model fine-tuned on Garchen Rinpoche's teachings
-- Silero VAD for voice activity detection
+- 30-second fixed chunking for long audio processing
 - Generates both SRT and WebVTT subtitle formats
 """
 
@@ -33,23 +35,17 @@ css = """
 .player-container audio {width: 100%;}
 """
 
-# Initialize models
-def init_models():
-    # Load Silero VAD
-    vad_model, utils = torch.hub.load(
-        repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True
-    )
-    get_speech_ts = utils[0]
-    
+# Initialize model
+def init_model():
     # Load Wav2Vec2 model
     model = Wav2Vec2ForCTC.from_pretrained(MODEL_NAME)
     processor = Wav2Vec2Processor.from_pretrained(MODEL_NAME)
     model.eval()
     
-    return vad_model, get_speech_ts, model, processor
+    return model, processor
 
-# Initialize models globally
-vad_model, get_speech_ts, model, processor = init_models()
+# Initialize model globally
+model, processor = init_model()
 
 def format_timestamp(seconds, format_type="srt"):
     """Convert seconds to SRT or WebVTT timestamp format"""
@@ -73,10 +69,10 @@ def create_subtitle_file(timestamps_with_text, output_path, format_type="srt"):
         for i, (start_time, end_time, text) in enumerate(timestamps_with_text, 1):
             if format_type == "srt":
                 f.write(f"{i}\n")
-                f.write(f"{format_timestamp(start_time/SAMPLE_RATE)} --> {format_timestamp(end_time/SAMPLE_RATE)}\n")
+                f.write(f"{format_timestamp(start_time)} --> {format_timestamp(end_time)}\n")
                 f.write(f"{text}\n\n")
             else:
-                f.write(f"{format_timestamp(start_time/SAMPLE_RATE, 'vtt')} --> {format_timestamp(end_time/SAMPLE_RATE, 'vtt')}\n")
+                f.write(f"{format_timestamp(start_time, 'vtt')} --> {format_timestamp(end_time, 'vtt')}\n")
                 f.write(f"{text}\n\n")
 
 def build_html_output(s: str, style: str = "result_item_success"):
@@ -127,35 +123,46 @@ def process_audio(audio_path: str):
         if sr != SAMPLE_RATE:
             wav = torchaudio.transforms.Resample(sr, SAMPLE_RATE)(wav)
         wav = wav.mean(dim=0)  # convert to mono
-        wav_np = wav.numpy()
-
-        # Get speech timestamps using Silero VAD
-        speech_timestamps = get_speech_ts(wav_np, vad_model, sampling_rate=SAMPLE_RATE)
-        if not speech_timestamps:
-            return (
-                build_html_output("No speech detected", "result_item_error"),
-                None,
-                None,
-                "",
-                "",
-            )
 
+        # Split audio into 30-second chunks
+        audio_length = wav.shape[0]
         timestamps_with_text = []
         transcriptions = []
         
-        for ts in speech_timestamps:
-            start, end = ts['start'], ts['end']
-            segment = wav[start:end]
-            if segment.dim() > 1:
-                segment = segment.squeeze()
-
-            inputs = processor(segment, sampling_rate=SAMPLE_RATE, return_tensors="pt", padding=True)
+        for start_sample in range(0, audio_length, CHUNK_SAMPLES):
+            end_sample = min(start_sample + CHUNK_SAMPLES, audio_length)
+            
+            # Convert sample positions to seconds
+            start_time = start_sample / SAMPLE_RATE
+            end_time = end_sample / SAMPLE_RATE
+            
+            # Extract chunk
+            chunk = wav[start_sample:end_sample]
+            
+            # Skip processing if chunk is too short (less than 0.5 seconds)
+            if chunk.shape[0] < 0.5 * SAMPLE_RATE:
+                continue
+                
+            # Process chunk through model
+            inputs = processor(chunk, sampling_rate=SAMPLE_RATE, return_tensors="pt", padding=True)
             with torch.no_grad():
                 logits = model(**inputs).logits
             predicted_ids = torch.argmax(logits, dim=-1)
             transcription = processor.decode(predicted_ids[0])
-            transcriptions.append(transcription)
-            timestamps_with_text.append((start, end, transcription))
+            
+            # Skip empty transcriptions
+            if transcription.strip():
+                transcriptions.append(transcription)
+                timestamps_with_text.append((start_time, end_time, transcription))
+
+        if not timestamps_with_text:
+            return (
+                build_html_output("No speech detected or recognized", "result_item_error"),
+                None,
+                None,
+                "",
+                "",
+            )
 
         # Generate subtitle files
         base_path = os.path.splitext(audio_path)[0]
@@ -238,4 +245,4 @@ with demo:
 if __name__ == "__main__":
     formatter = "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
     logging.basicConfig(format=formatter, level=logging.INFO)
-    demo.launch(share=True)
+    demo.launch(share=True)