Update app.py

app.py

@@ -3,7 +3,6 @@ import whisper
 import torch
 import os
 from pydub import AudioSegment
-from transformers import pipeline
 from faster_whisper import WhisperModel  # Import faster-whisper
 
 # Mapping of model names to Whisper model sizes
@@ -13,20 +12,7 @@ MODELS = {
     "Small (Balanced)": "small",
     "Medium (Accurate)": "medium",
     "Large (Most Accurate)": "large",
-    "Systran Faster Whisper Large v3": "Systran/faster-whisper-large-v3"  # Add the new model
-}
-
-# Fine-tuned models for specific languages
-FINE_TUNED_MODELS = {
-    "Tamil": {
-        "model": "vasista22/whisper-tamil-medium",
-        "language": "ta"
-    },
-    "Sinhala": {
-        "model": "Subhaka/whisper-small-Sinhala-Fine_Tune",  # Add the new fine-tuned model
-        "language": "si"  # Sinhala language code
-    },
-    # Add more fine-tuned models for other languages here
+    "Faster Whisper Large v3": "Systran/faster-whisper-large-v3"  # Renamed and set as default
 }
 
 # Mapping of full language names to language codes
@@ -138,18 +124,22 @@ CODE_TO_LANGUAGE_NAME = {v: k for k, v in LANGUAGE_NAME_TO_CODE.items()}
 
 def detect_language(audio_file):
     """Detect the language of the audio file."""
-    # Load the Whisper model (use "base" for faster detection)
-    model = whisper.load_model("base")
+    # Define device and compute type for faster-whisper
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    compute_type = "float32" if device == "cuda" else "int8"
     
-    # Convert audio to 16kHz mono for better compatibility with Whisper
+    # Load the faster-whisper model for language detection
+    model = WhisperModel(MODELS["Faster Whisper Large v3"], device=device, compute_type=compute_type)
+    
+    # Convert audio to 16kHz mono for better compatibility
     audio = AudioSegment.from_file(audio_file)
     audio = audio.set_frame_rate(16000).set_channels(1)
     processed_audio_path = "processed_audio.wav"
     audio.export(processed_audio_path, format="wav")
     
-    # Detect the language
-    result = model.transcribe(processed_audio_path, task="detect_language", fp16=False)
-    detected_language_code = result.get("language", "unknown")
+    # Detect the language using faster-whisper
+    segments, info = model.transcribe(processed_audio_path, task="translate", language=None)
+    detected_language_code = info.language
     
     # Get the full language name from the code
     detected_language = CODE_TO_LANGUAGE_NAME.get(detected_language_code, "Unknown Language")
@@ -159,7 +149,7 @@ def detect_language(audio_file):
     
     return f"Detected Language: {detected_language}"
 
-def transcribe_audio(audio_file, language="Auto Detect", model_size="Base (Faster)"):
+def transcribe_audio(audio_file, language="Auto Detect", model_size="Faster Whisper Large v3"):
     """Transcribe the audio file."""
     # Convert audio to 16kHz mono for better compatibility
     audio = AudioSegment.from_file(audio_file)
@@ -168,56 +158,38 @@ def transcribe_audio(audio_file, language="Auto Detect", model_size="Base (Faste
     audio.export(processed_audio_path, format="wav")
     
     # Load the appropriate model
-    if language in FINE_TUNED_MODELS:
-        # Use the fine-tuned Whisper model for the selected language
-        device = "cuda:0" if torch.cuda.is_available() else "cpu"
-        transcribe = pipeline(
-            task="automatic-speech-recognition",
-            model=FINE_TUNED_MODELS[language]["model"],
-            chunk_length_s=30,
-            device=device
+    if model_size == "Faster Whisper Large v3":
+        # Define device and compute type for faster-whisper
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        compute_type = "float32" if device == "cuda" else "int8"
+        
+        # Use faster-whisper for the Systran model
+        model = WhisperModel(MODELS[model_size], device=device, compute_type=compute_type)
+        segments, info = model.transcribe(
+            processed_audio_path,
+            task="transcribe",
+            word_timestamps=True,
+            repetition_penalty=1.1,
+            temperature=[0.0, 0.1, 0.2, 0.3, 0.4, 0.6, 0.8, 1.0],
         )
-        transcribe.model.config.forced_decoder_ids = transcribe.tokenizer.get_decoder_prompt_ids(
-            language=FINE_TUNED_MODELS[language]["language"],
-            task="transcribe"
-        )
-        result = transcribe(processed_audio_path)
-        transcription = result["text"]
-        detected_language = language
+        transcription = " ".join([segment.text for segment in segments])
+        detected_language_code = info.language
+        detected_language = CODE_TO_LANGUAGE_NAME.get(detected_language_code, "Unknown Language")
     else:
-        # Use the selected Whisper model
-        if model_size == "Systran Faster Whisper Large v3":
-            # Define device and compute type for faster-whisper
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            compute_type = "float32" if device == "cuda" else "int8"
-            
-            # Use faster-whisper for the Systran model
-            model = WhisperModel(MODELS[model_size], device=device, compute_type=compute_type)
-            segments, info = model.transcribe(
-                processed_audio_path,
-                task="transcribe",
-                word_timestamps=True,
-                repetition_penalty=1.1,
-                temperature=[0.0, 0.1, 0.2, 0.3, 0.4, 0.6, 0.8, 1.0],
-            )
-            transcription = " ".join([segment.text for segment in segments])
-            detected_language_code = info.language
+        # Use the standard Whisper model
+        model = whisper.load_model(MODELS[model_size])
+        
+        # Transcribe the audio
+        if language == "Auto Detect":
+            result = model.transcribe(processed_audio_path, fp16=False)  # Auto-detect language
+            detected_language_code = result.get("language", "unknown")
             detected_language = CODE_TO_LANGUAGE_NAME.get(detected_language_code, "Unknown Language")
         else:
-            # Use the standard Whisper model
-            model = whisper.load_model(MODELS[model_size])
-            
-            # Transcribe the audio
-            if language == "Auto Detect":
-                result = model.transcribe(processed_audio_path, fp16=False)  # Auto-detect language
-                detected_language_code = result.get("language", "unknown")
-                detected_language = CODE_TO_LANGUAGE_NAME.get(detected_language_code, "Unknown Language")
-            else:
-                language_code = LANGUAGE_NAME_TO_CODE.get(language, "en")  # Default to English if not found
-                result = model.transcribe(processed_audio_path, language=language_code, fp16=False)
-                detected_language = language
-            
-            transcription = result["text"]
+            language_code = LANGUAGE_NAME_TO_CODE.get(language, "en")  # Default to English if not found
+            result = model.transcribe(processed_audio_path, language=language_code, fp16=False)
+            detected_language = language
+        
+        transcription = result["text"]
     
     # Clean up processed audio file
     os.remove(processed_audio_path)
@@ -246,7 +218,7 @@ with gr.Blocks() as demo:
         model_dropdown = gr.Dropdown(
             choices=list(MODELS.keys()),  # Model options
             label="Select Model",
-            value="Base (Faster)",  # Default to "Base" model
+            value="Faster Whisper Large v3",  # Default to "Faster Whisper Large v3"
             interactive=True  # Allow model selection by default
         )
         transcribe_output = gr.Textbox(label="Transcription and Detected Language")