Update app.py

app.py

@@ -29,18 +29,11 @@ LANG_CODES = {
     "Malayalam": "ml"
 }
 
-# Updated model configurations for better HF Spaces compatibility
+# Updated model configurations with LARGE models for maximum accuracy
 ASR_MODELS = {
     "English": "openai/whisper-base.en",
-    "Tamil": "vasista22/whisper-tamil-base",  # Community model for Tamil
-    "Malayalam": "parambharat/whisper-small-ml"  # Community model for Malayalam
-}
-
-# Backup models in case primary ones fail
-FALLBACK_MODELS = {
-    "English": "openai/whisper-base.en",
-    "Tamil": "openai/whisper-small",
-    "Malayalam": "openai/whisper-small"
+    "Tamil": "ai4bharat/whisper-large-ta",      # LARGE AI4Bharat Tamil model (~1.5GB)
+    "Malayalam": "ai4bharat/whisper-large-ml"   # LARGE AI4Bharat Malayalam model (~1.5GB)
 }
 
 LANG_PRIMERS = {
@@ -95,49 +88,26 @@ SENTENCE_BANK = {
 asr_models = {}
 
 def load_asr_model(language):
-    """Load ASR model for specific language with fallback"""
+    """Load ASR model for specific language - PRIMARY MODELS ONLY"""
     if language not in asr_models:
+        model_name = ASR_MODELS[language]
+        print(f"🔄 Loading LARGE model for {language}: {model_name}")
+        
         try:
-            model_name = ASR_MODELS[language]
-            print(f"🔄 Loading ASR model for {language}: {model_name}")
+            processor = AutoProcessor.from_pretrained(model_name)
+            model = AutoModelForSpeechSeq2Seq.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
+                low_cpu_mem_usage=True,
+                use_safetensors=True
+            ).to(DEVICE)
+            
+            asr_models[language] = {"processor": processor, "model": model, "model_name": model_name}
+            print(f"✅ LARGE model loaded successfully for {language}")
             
-            # Try loading the primary model
-            try:
-                processor = AutoProcessor.from_pretrained(model_name)
-                model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                    model_name,
-                    torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
-                    low_cpu_mem_usage=True,
-                    use_safetensors=True
-                ).to(DEVICE)
-                
-                asr_models[language] = {"processor": processor, "model": model, "model_name": model_name}
-                print(f"✅ Primary ASR model loaded for {language}")
-                return asr_models[language]
-                
-            except Exception as e:
-                print(f"⚠️ Primary model failed for {language}: {e}")
-                print(f"🔄 Trying fallback model...")
-                
-                # Try fallback model
-                fallback_name = FALLBACK_MODELS[language]
-                processor = WhisperProcessor.from_pretrained(fallback_name)
-                model = WhisperForConditionalGeneration.from_pretrained(
-                    fallback_name,
-                    torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
-                    low_cpu_mem_usage=True
-                ).to(DEVICE)
-                
-                asr_models[language] = {"processor": processor, "model": model, "model_name": fallback_name}
-                print(f"✅ Fallback ASR model loaded for {language}")
-                
         except Exception as e:
-            print(f"❌ Failed to load any ASR model for {language}: {e}")
-            # Use English as ultimate fallback
-            if language != "English":
-                print(f"🔄 Using English ASR as final fallback for {language}")
-                load_asr_model("English")
-                asr_models[language] = asr_models["English"]
+            print(f"❌ Failed to load {model_name}: {e}")
+            raise Exception(f"Could not load {language} model. Please check model availability.")
     
     return asr_models[language]
 
@@ -354,40 +324,55 @@ def get_pronunciation_score(wer_val, cer_val):
 # ---------------- MAIN FUNCTION ---------------- #
 def compare_pronunciation(audio, language_choice, intended_sentence):
     """Main function to compare pronunciation"""
+    print(f"🔍 Starting analysis with language: {language_choice}")
+    print(f"📝 Audio file: {audio}")
+    print(f"🎯 Intended sentence: {intended_sentence}")
+    
     if audio is None:
+        print("❌ No audio provided")
         return ("❌ Please record audio first.", "", "", "", "", "", "", "", "", "", "", "", "")
     
     if not intended_sentence.strip():
+        print("❌ No intended sentence")
         return ("❌ Please generate a practice sentence first.", "", "", "", "", "", "", "", "", "", "", "", "")
     
     try:
         print(f"🔍 Analyzing pronunciation for {language_choice}...")
         
         # Pass 1: Raw transcription
+        print("🔄 Starting Pass 1 transcription...")
         primer_weak, _ = LANG_PRIMERS[language_choice]
         actual_text = transcribe_audio(audio, language_choice, primer_weak, force_language=True)
+        print(f"✅ Pass 1 result: {actual_text}")
         
         # Pass 2: Target-biased transcription with stronger prompt
+        print("🔄 Starting Pass 2 transcription...")
         _, primer_strong = LANG_PRIMERS[language_choice]
         strict_prompt = f"{primer_strong}\nExpected: {intended_sentence}"
         corrected_text = transcribe_audio(audio, language_choice, strict_prompt, force_language=True)
+        print(f"✅ Pass 2 result: {corrected_text}")
         
         # Handle transcription errors
         if actual_text.startswith("Error:"):
+            print(f"❌ Transcription error: {actual_text}")
             return (f"❌ {actual_text}", "", "", "", "", "", "", "", "", "", "", "", "")
         
         # Calculate error metrics
         try:
+            print("🔄 Calculating error metrics...")
             wer_val = jiwer.wer(intended_sentence, actual_text)
             cer_val = jiwer.cer(intended_sentence, actual_text)
+            print(f"✅ WER: {wer_val:.3f}, CER: {cer_val:.3f}")
         except Exception as e:
-            print(f"Error calculating metrics: {e}")
+            print(f"❌ Error calculating metrics: {e}")
             wer_val, cer_val = 1.0, 1.0
         
         # Get pronunciation score and feedback
         score_text, feedback = get_pronunciation_score(wer_val, cer_val)
+        print(f"✅ Score: {score_text}")
         
         # Transliterations for both actual and intended
+        print("🔄 Generating transliterations...")
         actual_hk = transliterate_to_hk(actual_text, language_choice)
         target_hk = transliterate_to_hk(intended_sentence, language_choice)
         
@@ -396,11 +381,13 @@ def compare_pronunciation(audio, language_choice, intended_sentence):
             actual_hk = f"⚠️ Expected {language_choice} script, got mixed/other script"
         
         # Visual feedback
+        print("🔄 Generating visual feedback...")
         diff_html = highlight_differences(intended_sentence, actual_text)
         char_html = char_level_highlight(intended_sentence, actual_text)
         
         # Status message with detailed feedback
         status = f"✅ Analysis Complete - {score_text}\n💬 {feedback}"
+        print(f"✅ Analysis completed successfully")
         
         return (
             status,
@@ -421,8 +408,10 @@ def compare_pronunciation(audio, language_choice, intended_sentence):
         
     except Exception as e:
         error_msg = f"❌ Analysis Error: {str(e)[:200]}"
-        print(f"Analysis error: {e}")
-        return (error_msg, "", "", "", "", "", "", "", "", "", "", "", "")
+        print(f"❌ FATAL ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        return (error_msg, str(e), "", "", "", "", "", "", "", "", "", "", "")
 
 # ---------------- UI ---------------- #
 def create_interface():
@@ -534,30 +523,28 @@ def create_interface():
         gr.Markdown("""
         ---
         ### 🔧 Technical Details:
-        - **ASR Models**: Community-trained Whisper models optimized for Tamil & Malayalam
+        - **ASR Models**: 
+          - **Tamil**: AI4Bharat Whisper-LARGE-TA (~1.5GB, maximum accuracy)
+          - **Malayalam**: AI4Bharat Whisper-LARGE-ML (~1.5GB, maximum accuracy)  
+          - **English**: OpenAI Whisper-Base-EN (optimized for English)
+        - **Performance**: Using largest available models for best pronunciation assessment
         - **Metrics**: WER (Word Error Rate) and CER (Character Error Rate)
         - **Transliteration**: Harvard-Kyoto system for Indic scripts
         - **Analysis**: Dual-pass approach for comprehensive feedback
         
-        **Note**: TTS (Text-to-Speech) reference audio will be added in future updates.
-        **Languages**: Currently supports English, Tamil, and Malayalam.
+        **Note**: Large models provide maximum accuracy but require longer initial loading time.
+        **Languages**: English, Tamil, and Malayalam with specialized large models.
         """)
     
     return demo
 
 # ---------------- LAUNCH ---------------- #
 if __name__ == "__main__":
-    print("🚀 Starting Multilingual Pronunciation Trainer...")
+    print("🚀 Starting Multilingual Pronunciation Trainer with LARGE models...")
     print(f"🔧 Device: {DEVICE}")
     print(f"🔧 PyTorch version: {torch.__version__}")
-    
-    # Pre-load English model for faster startup
-    print("📦 Pre-loading English model...")
-    try:
-        load_asr_model("English")
-        print("✅ English model loaded successfully")
-    except Exception as e:
-        print(f"⚠️ Warning: Could not pre-load English model: {e}")
+    print("📦 Models will be loaded on-demand for best performance...")
+    print("⚡ Using AI4Bharat LARGE models for maximum accuracy!")
     
     demo = create_interface()
     demo.launch(