Update app.py

app.py

@@ -6,6 +6,8 @@ import jiwer
 import torch
 import warnings
 import contextlib
+import traceback
+import gc
 from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq, pipeline
 import librosa
 import numpy as np
@@ -15,18 +17,21 @@ try:
     from indic_transliteration import sanscript
     from indic_transliteration.sanscript import transliterate
     INDIC_OK = True
+    print("✅ Transliteration available")
 except:
     INDIC_OK = False
-    print("⚠️ indic_transliteration not available. Transliteration features disabled.")
+    print("⚠️ indic_transliteration not available. Install with: pip install indic-transliteration")
 
 # Optional HF Spaces GPU decorator
 try:
     import spaces
     GPU_DECORATOR = spaces.GPU
+    print("✅ HF Spaces GPU decorator available")
 except:
     class _NoOp:
         def __call__(self, f): return f
     GPU_DECORATOR = _NoOp()
+    print("⚠️ HF Spaces not available (normal for local usage)")
 
 warnings.filterwarnings("ignore")
 
@@ -35,7 +40,12 @@ DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 DEVICE_INDEX = 0 if DEVICE == "cuda" else -1
 DTYPE = torch.float16 if DEVICE == "cuda" else torch.float32
 amp_ctx = torch.cuda.amp.autocast if DEVICE == "cuda" else contextlib.nullcontext
-print(f"🔧 Using device: {DEVICE}")
+
+print(f"🔧 Device: {DEVICE}")
+print(f"🔧 PyTorch version: {torch.__version__}")
+if DEVICE == "cuda":
+    print(f"🔧 CUDA available: {torch.cuda.is_available()}")
+    print(f"🔧 GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB")
 
 LANG_CODES = {
     "English": "en",
@@ -44,15 +54,12 @@ LANG_CODES = {
     "Hindi": "hi"
 }
 
-# Primary: IndicWhisper
-INDICWHISPER_MODEL = "parthiv11/indic_whisper_nodcil"
-
-# Specialized models for better accuracy
+# Simplified model setup - use only reliable models
 SPECIALIZED_MODELS = {
     "English": "openai/whisper-base.en",
-    "Tamil": "vasista22/whisper-tamil-large-v2",
-    "Malayalam": "thennal/whisper-medium-ml",
-    "Hindi": "openai/whisper-large-v2"  # Using general model for Hindi
+    "Tamil": "openai/whisper-large-v2",  # More reliable fallback
+    "Malayalam": "openai/whisper-large-v2",  # More reliable fallback  
+    "Hindi": "openai/whisper-large-v2"
 }
 
 SCRIPT_PATTERNS = {
@@ -64,9 +71,9 @@ SCRIPT_PATTERNS = {
 
 # Transliteration mappings
 TRANSLITERATION_SCRIPTS = {
-    "Tamil": sanscript.TAMIL,
-    "Malayalam": sanscript.MALAYALAM, 
-    "Hindi": sanscript.DEVANAGARI,
+    "Tamil": sanscript.TAMIL if INDIC_OK else None,
+    "Malayalam": sanscript.MALAYALAM if INDIC_OK else None,
+    "Hindi": sanscript.DEVANAGARI if INDIC_OK else None,
     "English": None
 }
 
@@ -102,48 +109,71 @@ SENTENCE_BANK = {
 }
 
 # Model cache
-primary_pipeline = None
-specialized_models = {}
+models = {}
+
+# ---------------- SAFE HELPERS ---------------- #
+def safe_operation(func, *args, **kwargs):
+    """Wrapper for safe operations with detailed error reporting"""
+    try:
+        return func(*args, **kwargs), None
+    except Exception as e:
+        error_msg = f"Error in {func.__name__}: {str(e)}"
+        print(f"❌ {error_msg}")
+        print(f"🔍 Traceback: {traceback.format_exc()}")
+        return None, error_msg
 
-# ---------------- HELPERS ---------------- #
 def get_random_sentence(language_choice):
-    return random.choice(SENTENCE_BANK[language_choice])
+    try:
+        return random.choice(SENTENCE_BANK[language_choice])
+    except Exception as e:
+        print(f"❌ Error getting sentence: {e}")
+        return "Error loading sentence"
 
 def is_correct_script(text, lang_name):
     """Check if text contains the expected script for the language"""
-    if not text.strip():
-        return False
-    pattern = SCRIPT_PATTERNS.get(lang_name)
-    if not pattern:
-        return True
-    return bool(pattern.search(text))
+    try:
+        if not text or not text.strip():
+            return False
+        pattern = SCRIPT_PATTERNS.get(lang_name)
+        if not pattern:
+            return True
+        return bool(pattern.search(text))
+    except Exception as e:
+        print(f"❌ Script check error: {e}")
+        return True  # Default to True to avoid blocking
 
 def transliterate_text(text, lang_choice, to_romanized=True):
     """Transliterate text to/from romanized form"""
-    if not INDIC_OK or not text.strip():
-        return text
-    
-    source_script = TRANSLITERATION_SCRIPTS.get(lang_choice)
-    if not source_script:
-        return text
-    
     try:
+        if not INDIC_OK or not text or not text.strip():
+            return text
+        
+        source_script = TRANSLITERATION_SCRIPTS.get(lang_choice)
+        if not source_script:
+            return text
+        
         if to_romanized:
-            # Convert to Harvard-Kyoto (romanized)
             return transliterate(text, source_script, sanscript.HK)
         else:
-            # Convert from romanized to native script (if needed)
             return transliterate(text, sanscript.HK, source_script)
     except Exception as e:
         print(f"⚠️ Transliteration failed: {e}")
         return text
 
 def preprocess_audio(audio_path, target_sr=16000):
-    """Enhanced audio preprocessing"""
+    """Enhanced audio preprocessing with better error handling"""
     try:
+        print(f"🔊 Processing audio: {audio_path}")
+        
+        if not audio_path:
+            return None, "No audio file provided"
+        
+        # Load audio
         audio, sr = librosa.load(audio_path, sr=target_sr, mono=True)
+        print(f"🔊 Audio loaded: shape={audio.shape}, sr={sr}")
+        
         if audio is None or len(audio) == 0:
-            return None, None
+            return None, "Empty audio file"
         
         # Normalize audio
         audio = audio.astype(np.float32)
@@ -154,374 +184,282 @@ def preprocess_audio(audio_path, target_sr=16000):
         # Trim silence
         audio, _ = librosa.effects.trim(audio, top_db=20)
         
-        # Check minimum length (0.1 seconds)
-        if len(audio) < int(target_sr * 0.1):
-            return None, None
-            
-        return audio, target_sr
+        # Check minimum length (0.5 seconds)
+        min_length = int(target_sr * 0.5)
+        if len(audio) < min_length:
+            return None, f"Audio too short: {len(audio)/target_sr:.2f}s (minimum 0.5s)"
+        
+        print(f"✅ Audio processed successfully: {len(audio)/target_sr:.2f}s")
+        return audio, sr
+        
     except Exception as e:
-        print(f"⚠️ Audio preprocessing failed: {e}")
-        return None, None
+        error_msg = f"Audio preprocessing failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        return None, error_msg
 
-# ---------------- MODEL LOADERS ---------------- #
-@GPU_DECORATOR
-def load_primary_model():
-    """Load the primary IndicWhisper model"""
-    global primary_pipeline
-    if primary_pipeline is not None:
-        return primary_pipeline
+# ---------------- SIMPLIFIED MODEL LOADERS ---------------- #
+def load_whisper_model(model_name, language=None):
+    """Load a single Whisper model with robust error handling"""
+    model_key = f"{model_name}_{language}"
+    
+    if model_key in models:
+        print(f"✅ Using cached model: {model_key}")
+        return models[model_key], None
     
     try:
-        print(f"🔄 Loading primary model: {INDICWHISPER_MODEL}")
+        print(f"🔄 Loading model: {model_name}")
         
-        # Try direct loading first
-        primary_pipeline = pipeline(
+        # Clear GPU memory first
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+            gc.collect()
+        
+        # Load with pipeline (simpler and more robust)
+        pipeline_model = pipeline(
             "automatic-speech-recognition",
-            model=INDICWHISPER_MODEL,
+            model=model_name,
             device=DEVICE_INDEX,
             torch_dtype=DTYPE,
-            trust_remote_code=True
+            return_timestamps=False
         )
-        print("✅ Primary model loaded successfully!")
-        return primary_pipeline
-        
-    except Exception as e:
-        print(f"⚠️ Primary model failed, using fallback: {e}")
-        # Fallback to base Whisper
-        primary_pipeline = pipeline(
-            "automatic-speech-recognition", 
-            model="openai/whisper-large-v2",
-            device=DEVICE_INDEX,
-            torch_dtype=DTYPE
-        )
-        print("✅ Fallback model loaded!")
-        return primary_pipeline
-
-@GPU_DECORATOR  
-def load_specialized_model(language):
-    """Load specialized model for specific language"""
-    if language in specialized_models:
-        return specialized_models[language]
-    
-    model_name = SPECIALIZED_MODELS[language]
-    print(f"🔄 Loading specialized {language} model: {model_name}")
-    
-    try:
-        processor = AutoProcessor.from_pretrained(model_name)
-        model = AutoModelForSpeechSeq2Seq.from_pretrained(
-            model_name,
-            torch_dtype=DTYPE,
-            device_map="auto" if DEVICE == "cuda" else None
-        ).to(DEVICE)
         
-        specialized_models[language] = {
-            "processor": processor,
-            "model": model
-        }
-        print(f"✅ Specialized {language} model loaded!")
-        return specialized_models[language]
+        models[model_key] = pipeline_model
+        print(f"✅ Model loaded successfully: {model_name}")
+        return pipeline_model, None
         
     except Exception as e:
-        print(f"❌ Failed to load specialized {language} model: {e}")
-        return None
+        error_msg = f"Failed to load {model_name}: {str(e)}"
+        print(f"❌ {error_msg}")
+        return None, error_msg
 
 # ---------------- TRANSCRIPTION ---------------- #
-@GPU_DECORATOR
-def transcribe_with_primary(audio_path, language):
-    """Transcribe using primary IndicWhisper model"""
+def transcribe_audio_safe(audio_path, model_name, language):
+    """Safe transcription with comprehensive error handling"""
     try:
-        pipeline_model = load_primary_model()
-        lang_code = LANG_CODES[language]
+        print(f"🎤 Starting transcription with {model_name} for {language}")
+        
+        # Load model
+        model, model_error = load_whisper_model(model_name, language)
+        if model is None:
+            return None, f"Model loading failed: {model_error}"
+        
+        # Set language if supported
+        lang_code = LANG_CODES.get(language, "en")
+        generate_kwargs = {
+            "max_new_tokens": 200,
+            "num_beams": 1,  # Faster decoding
+            "do_sample": False
+        }
         
-        # Set language forcing if possible
+        # Try to set language (some models support this)
         try:
-            if hasattr(pipeline_model, "model") and hasattr(pipeline_model, "tokenizer"):
-                forced_ids = pipeline_model.tokenizer.get_decoder_prompt_ids(
+            if hasattr(model, "model") and hasattr(model, "tokenizer"):
+                forced_ids = model.tokenizer.get_decoder_prompt_ids(
                     language=lang_code, 
                     task="transcribe"
                 )
                 if forced_ids:
-                    pipeline_model.model.config.forced_decoder_ids = forced_ids
-        except Exception as e:
-            print(f"⚠️ Language forcing failed: {e}")
+                    model.model.config.forced_decoder_ids = forced_ids
+                    print(f"🔧 Language set to: {lang_code}")
+        except Exception as lang_error:
+            print(f"⚠️ Language forcing failed (continuing anyway): {lang_error}")
         
+        # Transcribe
+        print(f"🔄 Transcribing...")
         with amp_ctx():
-            result = pipeline_model(audio_path)
+            result = model(audio_path, generate_kwargs=generate_kwargs)
         
         if isinstance(result, dict):
-            return result.get("text", "").strip()
-        return str(result).strip()
-        
-    except Exception as e:
-        return f"Primary transcription error: {str(e)}"
-
-@GPU_DECORATOR
-def transcribe_with_specialized(audio_path, language):
-    """Transcribe using specialized model"""
-    try:
-        model_components = load_specialized_model(language)
-        if not model_components:
-            return "Specialized model not available"
-        
-        # Preprocess audio
-        audio, sr = preprocess_audio(audio_path)
-        if audio is None:
-            return "Audio preprocessing failed"
-        
-        # Process with specialized model
-        inputs = model_components["processor"](
-            audio,
-            sampling_rate=sr,
-            return_tensors="pt"
-        )
-        
-        input_features = inputs.input_features.to(DEVICE)
-        
-        # Generation parameters
-        gen_kwargs = {
-            "inputs": input_features,
-            "max_length": 200,
-            "num_beams": 3,
-            "do_sample": False
-        }
-        
-        # Language forcing for non-English
-        if language != "English":
-            try:
-                forced_ids = model_components["processor"].tokenizer.get_decoder_prompt_ids(
-                    language=LANG_CODES[language],
-                    task="transcribe"
-                )
-                if forced_ids:
-                    gen_kwargs["forced_decoder_ids"] = forced_ids
-            except Exception as e:
-                print(f"⚠️ Specialized language forcing failed: {e}")
-        
-        # Generate transcription
-        with torch.no_grad(), amp_ctx():
-            generated_ids = model_components["model"].generate(**gen_kwargs)
-        
-        # Decode result
-        transcription = model_components["processor"].batch_decode(
-            generated_ids,
-            skip_special_tokens=True
-        )[0]
+            text = result.get("text", "").strip()
+        else:
+            text = str(result).strip()
         
-        return transcription.strip()
+        print(f"✅ Transcription complete: '{text[:50]}...'")
+        return text, None
         
     except Exception as e:
-        return f"Specialized transcription error: {str(e)}"
+        error_msg = f"Transcription failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        print(f"🔍 Full traceback: {traceback.format_exc()}")
+        return None, error_msg
 
 # ---------------- ANALYSIS ---------------- #
-def compute_metrics(reference, hypothesis):
+def compute_metrics_safe(reference, hypothesis):
     """Compute WER and CER with error handling"""
     try:
-        # Clean up texts
         ref_clean = reference.strip()
         hyp_clean = hypothesis.strip()
         
         if not ref_clean or not hyp_clean:
-            return 1.0, 1.0
+            return 1.0, 1.0, "Empty text"
         
-        # Compute WER and CER
         wer = jiwer.wer(ref_clean, hyp_clean)
         cer = jiwer.cer(ref_clean, hyp_clean)
         
-        return wer, cer
+        return wer, cer, None
     except Exception as e:
-        print(f"⚠️ Metric computation failed: {e}")
-        return 1.0, 1.0
+        print(f"❌ Metric computation failed: {e}")
+        return 1.0, 1.0, str(e)
 
 def get_pronunciation_score(wer, cer):
     """Convert error rates to intuitive scores and feedback"""
-    # Weighted combination (WER is more important)
-    combined_error = (wer * 0.7) + (cer * 0.3)
-    accuracy = 1 - combined_error
-    
-    if accuracy >= 0.95:
-        return "🏆 Perfect!", "Outstanding pronunciation! Native-like accuracy.", "#d4edda"
-    elif accuracy >= 0.85:
-        return "🎉 Excellent!", "Very good pronunciation with minor variations.", "#d1ecf1"
-    elif accuracy >= 0.70:
-        return "👍 Good!", "Good pronunciation, practice specific sounds.", "#fff3cd"
-    elif accuracy >= 0.50:
-        return "📚 Needs Practice", "Focus on clearer pronunciation and rhythm.", "#f8d7da"
-    else:
-        return "💪 Keep Trying!", "Break down into smaller parts and practice slowly.", "#f5c6cb"
-
-def create_detailed_comparison(intended, actual, lang_choice):
-    """Create detailed side-by-side comparison with transliteration"""
-    
-    # Original scripts
-    intended_orig = intended.strip()
-    actual_orig = actual.strip()
-    
-    # Transliterations
-    intended_translit = transliterate_text(intended_orig, lang_choice, to_romanized=True)
-    actual_translit = transliterate_text(actual_orig, lang_choice, to_romanized=True)
-    
-    # Word-level highlighting
-    word_diff_orig = highlight_word_differences(intended_orig, actual_orig)
-    word_diff_translit = highlight_word_differences(intended_translit, actual_translit)
-    
-    # Character-level highlighting  
-    char_diff_orig = highlight_char_differences(intended_orig, actual_orig)
-    char_diff_translit = highlight_char_differences(intended_translit, actual_translit)
-    
-    return {
-        "intended_orig": intended_orig,
-        "actual_orig": actual_orig,
-        "intended_translit": intended_translit,
-        "actual_translit": actual_translit,
-        "word_diff_orig": word_diff_orig,
-        "word_diff_translit": word_diff_translit,
-        "char_diff_orig": char_diff_orig,
-        "char_diff_translit": char_diff_translit
-    }
-
-def highlight_word_differences(reference, hypothesis):
-    """Highlight word-level differences with colors"""
-    ref_words = reference.split()
-    hyp_words = hypothesis.split()
-    
-    sm = difflib.SequenceMatcher(None, ref_words, hyp_words)
-    html_output = []
-    
-    for tag, i1, i2, j1, j2 in sm.get_opcodes():
-        if tag == 'equal':
-            # Correct words - green background
-            html_output.extend([
-                f"<span style='background-color:#d4edda; color:#155724; padding:2px 4px; margin:1px; border-radius:3px'>{word}</span>"
-                for word in ref_words[i1:i2]
-            ])
-        elif tag == 'replace':
-            # Wrong words - red background for reference, orange for hypothesis
-            html_output.extend([
-                f"<span style='background-color:#f8d7da; color:#721c24; padding:2px 4px; margin:1px; border-radius:3px; text-decoration:line-through'>{word}</span>"
-                for word in ref_words[i1:i2]
-            ])
-            html_output.extend([
-                f"<span style='background-color:#fff3cd; color:#856404; padding:2px 4px; margin:1px; border-radius:3px'>→{word}</span>"
-                for word in hyp_words[j1:j2]
-            ])
-        elif tag == 'delete':
-            # Missing words - red background
-            html_output.extend([
-                f"<span style='background-color:#f8d7da; color:#721c24; padding:2px 4px; margin:1px; border-radius:3px; text-decoration:line-through'>{word}</span>"
-                for word in ref_words[i1:i2]
-            ])
-        elif tag == 'insert':
-            # Extra words - orange background
-            html_output.extend([
-                f"<span style='background-color:#fff3cd; color:#856404; padding:2px 4px; margin:1px; border-radius:3px'>+{word}</span>"
-                for word in hyp_words[j1:j2]
-            ])
-    
-    return " ".join(html_output)
-
-def highlight_char_differences(reference, hypothesis):
-    """Highlight character-level differences"""
-    sm = difflib.SequenceMatcher(None, list(reference), list(hypothesis))
-    html_output = []
-    
-    for tag, i1, i2, j1, j2 in sm.get_opcodes():
-        if tag == 'equal':
-            # Correct characters - green
-            html_output.extend([
-                f"<span style='color:#28a745'>{char}</span>"
-                for char in reference[i1:i2]
-            ])
-        elif tag in ('replace', 'delete'):
-            # Wrong/missing characters - red with underline
-            html_output.extend([
-                f"<span style='color:#dc3545; text-decoration:underline; font-weight:bold'>{char}</span>"
-                for char in reference[i1:i2]
-            ])
-        elif tag == 'insert':
-            # Extra characters - orange
-            html_output.extend([
-                f"<span style='color:#fd7e14; font-weight:bold'>{char}</span>"
-                for char in hypothesis[j1:j2]
-            ])
-    
-    return "".join(html_output)
+    try:
+        combined_error = (wer * 0.7) + (cer * 0.3)
+        accuracy = 1 - combined_error
+        
+        if accuracy >= 0.95:
+            return "🏆 Perfect!", "Outstanding pronunciation! Native-like accuracy."
+        elif accuracy >= 0.85:
+            return "🎉 Excellent!", "Very good pronunciation with minor variations."
+        elif accuracy >= 0.70:
+            return "👍 Good!", "Good pronunciation, practice specific sounds."
+        elif accuracy >= 0.50:
+            return "📚 Needs Practice", "Focus on clearer pronunciation and rhythm."
+        else:
+            return "💪 Keep Trying!", "Break down into smaller parts and practice slowly."
+    except Exception as e:
+        print(f"❌ Score calculation failed: {e}")
+        return "❓ Unknown", "Could not calculate score"
 
-def analyze_pronunciation_errors(intended, actual, lang_choice):
-    """Provide specific feedback about pronunciation errors"""
-    comparison = create_detailed_comparison(intended, actual, lang_choice)
-    
-    # Analyze error patterns
-    intended_words = intended.split()
-    actual_words = actual.split()
-    
-    error_analysis = []
-    
-    # Length difference analysis
-    if len(actual_words) < len(intended_words):
-        missing_count = len(intended_words) - len(actual_words)
-        error_analysis.append(f"🔍 You missed {missing_count} word(s). Try speaking more slowly.")
-    elif len(actual_words) > len(intended_words):
-        extra_count = len(actual_words) - len(intended_words) 
-        error_analysis.append(f"🔍 You added {extra_count} extra word(s). Focus on the exact sentence.")
-    
-    # Script verification
-    if not is_correct_script(actual, lang_choice):
-        error_analysis.append(f"⚠️ The transcription doesn't contain {lang_choice} script. Check your pronunciation.")
-    
-    # WER/CER based feedback
-    wer, cer = compute_metrics(intended, actual)
-    
-    if wer > 0.5:
-        error_analysis.append("🎯 Focus on pronouncing each word clearly and separately.")
-    elif wer > 0.3:
-        error_analysis.append("🎯 Good overall, but some words need clearer pronunciation.")
-    
-    if cer > 0.3:
-        error_analysis.append("🔤 Pay attention to individual sounds and syllables.")
-    
-    return error_analysis, comparison
+def highlight_differences_safe(reference, hypothesis):
+    """Safe highlighting with error handling"""
+    try:
+        if not reference or not hypothesis:
+            return "No text to compare", "No text to compare"
+        
+        # Word-level highlighting
+        ref_words = reference.split()
+        hyp_words = hypothesis.split()
+        
+        sm = difflib.SequenceMatcher(None, ref_words, hyp_words)
+        word_html = []
+        
+        for tag, i1, i2, j1, j2 in sm.get_opcodes():
+            if tag == 'equal':
+                word_html.extend([
+                    f"<span style='background-color:#d4edda; color:#155724; padding:2px 4px; margin:1px; border-radius:3px'>{word}</span>"
+                    for word in ref_words[i1:i2]
+                ])
+            elif tag == 'replace':
+                word_html.extend([
+                    f"<span style='background-color:#f8d7da; color:#721c24; padding:2px 4px; margin:1px; border-radius:3px; text-decoration:line-through'>{word}</span>"
+                    for word in ref_words[i1:i2]
+                ])
+                word_html.extend([
+                    f"<span style='background-color:#fff3cd; color:#856404; padding:2px 4px; margin:1px; border-radius:3px'>→{word}</span>"
+                    for word in hyp_words[j1:j2]
+                ])
+            elif tag == 'delete':
+                word_html.extend([
+                    f"<span style='background-color:#f8d7da; color:#721c24; padding:2px 4px; margin:1px; border-radius:3px; text-decoration:line-through'>{word}</span>"
+                    for word in ref_words[i1:i2]
+                ])
+            elif tag == 'insert':
+                word_html.extend([
+                    f"<span style='background-color:#fff3cd; color:#856404; padding:2px 4px; margin:1px; border-radius:3px'>+{word}</span>"
+                    for word in hyp_words[j1:j2]
+                ])
+        
+        # Character-level highlighting
+        sm_char = difflib.SequenceMatcher(None, list(reference), list(hypothesis))
+        char_html = []
+        
+        for tag, i1, i2, j1, j2 in sm_char.get_opcodes():
+            if tag == 'equal':
+                char_html.extend([
+                    f"<span style='color:#28a745'>{char}</span>"
+                    for char in reference[i1:i2]
+                ])
+            elif tag in ('replace', 'delete'):
+                char_html.extend([
+                    f"<span style='color:#dc3545; text-decoration:underline; font-weight:bold'>{char}</span>"
+                    for char in reference[i1:i2]
+                ])
+            elif tag == 'insert':
+                char_html.extend([
+                    f"<span style='color:#fd7e14; font-weight:bold'>{char}</span>"
+                    for char in hypothesis[j1:j2]
+                ])
+        
+        return " ".join(word_html), "".join(char_html)
+        
+    except Exception as e:
+        print(f"❌ Highlighting failed: {e}")
+        return f"Error highlighting: {str(e)}", f"Error highlighting: {str(e)}"
 
 # ---------------- MAIN FUNCTION ---------------- #
 @GPU_DECORATOR
 def compare_pronunciation(audio, language_choice, intended_sentence):
-    """Main function to analyze pronunciation"""
-    
-    if audio is None:
-        return ("❌ Please record audio first", "", "", "", "", "", "", "", "", "", "")
-    
-    if not intended_sentence.strip():
-        return ("❌ Please generate a sentence first", "", "", "", "", "", "", "", "", "", "")
-    
-    print(f"🔍 Analyzing pronunciation for {language_choice}...")
-    
-    # Get transcriptions from both models
-    primary_result = transcribe_with_primary(audio, language_choice)
-    specialized_result = transcribe_with_specialized(audio, language_choice)
-    
-    # Choose best result (prefer specialized if successful)
-    if not specialized_result.startswith("Specialized") and specialized_result.strip():
-        best_transcription = specialized_result
-        best_source = "Specialized Model"
-    elif not primary_result.startswith("Primary") and primary_result.strip():
-        best_transcription = primary_result  
-        best_source = "Primary Model"
-    else:
-        return (
-            f"❌ Both models failed:\nPrimary: {primary_result}\nSpecialized: {specialized_result}",
-            "", "", "", "", "", "", "", "", "", ""
-        )
-    
-    # Analyze pronunciation
-    error_analysis, comparison = analyze_pronunciation_errors(
-        intended_sentence, best_transcription, language_choice
-    )
+    """Main function with comprehensive error handling"""
     
-    # Compute metrics
-    wer, cer = compute_metrics(intended_sentence, best_transcription)
-    score, feedback, color = get_pronunciation_score(wer, cer)
+    print(f"\n🔍 Starting pronunciation analysis...")
+    print(f"📝 Language: {language_choice}")
+    print(f"🎯 Target: {intended_sentence[:50]}...")
     
-    # Create status message
-    status_msg = f"""✅ Analysis Complete!
+    try:
+        # Validate inputs
+        if audio is None:
+            return ("❌ Please record audio first", "", "", "", "", "", "", "", "", "", "")
+        
+        if not intended_sentence or not intended_sentence.strip():
+            return ("❌ Please generate a sentence first", "", "", "", "", "", "", "", "", "", "")
+        
+        # Preprocess audio
+        processed_audio, audio_error = preprocess_audio(audio)
+        if processed_audio is None:
+            return (f"❌ Audio processing failed: {audio_error}", "", "", "", "", "", "", "", "", "", "")
+        
+        # Get models for this language
+        primary_model = "openai/whisper-large-v2"  # Always reliable
+        specialized_model = SPECIALIZED_MODELS.get(language_choice, primary_model)
+        
+        print(f"🤖 Using models: Primary={primary_model}, Specialized={specialized_model}")
+        
+        # Try primary transcription
+        primary_text, primary_error = transcribe_audio_safe(audio, primary_model, language_choice)
+        
+        # Try specialized transcription (if different from primary)
+        if specialized_model != primary_model:
+            specialized_text, specialized_error = transcribe_audio_safe(audio, specialized_model, language_choice)
+        else:
+            specialized_text, specialized_error = primary_text, primary_error
+        
+        # Choose best result
+        best_text = None
+        best_source = "None"
+        
+        if primary_text and not primary_text.startswith("Error"):
+            best_text = primary_text
+            best_source = "Primary Model"
+        elif specialized_text and not specialized_text.startswith("Error"):
+            best_text = specialized_text
+            best_source = "Specialized Model"
+        
+        if not best_text:
+            error_details = f"Primary: {primary_error or 'Unknown error'}\nSpecialized: {specialized_error or 'Unknown error'}"
+            return (f"❌ Both models failed:\n{error_details}", 
+                   primary_text or "Failed", specialized_text or "Failed", 
+                   "", "", "", "", "", "", "", "")
+        
+        print(f"✅ Best transcription from {best_source}: '{best_text}'")
+        
+        # Compute metrics
+        wer, cer, metric_error = compute_metrics_safe(intended_sentence, best_text)
+        if metric_error:
+            print(f"⚠️ Metric computation warning: {metric_error}")
+        
+        # Get score and feedback
+        score, feedback = get_pronunciation_score(wer, cer)
+        
+        # Create visual comparisons
+        word_diff, char_diff = highlight_differences_safe(intended_sentence, best_text)
+        
+        # Transliterations
+        intended_translit = transliterate_text(intended_sentence, language_choice, to_romanized=True)
+        actual_translit = transliterate_text(best_text, language_choice, to_romanized=True)
+        
+        # Create status message
+        status_msg = f"""✅ Analysis Complete!
 
 {score}
 {feedback}
@@ -530,22 +468,31 @@ def compare_pronunciation(audio, language_choice, intended_sentence):
 📊 Word Accuracy: {(1-wer)*100:.1f}%
 📈 Character Accuracy: {(1-cer)*100:.1f}%
 
-🔍 Analysis:
-""" + "\n".join(error_analysis)
-    
-    return (
-        status_msg,
-        primary_result,
-        specialized_result, 
-        f"{wer:.3f} ({(1-wer)*100:.1f}%)",
-        f"{cer:.3f} ({(1-cer)*100:.1f}%)",
-        comparison["intended_orig"],
-        comparison["actual_orig"],
-        comparison["intended_translit"],
-        comparison["actual_translit"],
-        comparison["word_diff_orig"],
-        comparison["char_diff_orig"]
-    )
+🔍 Quick Tips:
+• Green = Correct pronunciation ✅
+• Red = Wrong/missing words ❌  
+• Orange = Added/substituted words 🔄
+"""
+        
+        return (
+            status_msg,
+            primary_text or "Failed",
+            specialized_text or "Failed",
+            f"{wer:.3f} ({(1-wer)*100:.1f}%)",
+            f"{cer:.3f} ({(1-cer)*100:.1f}%)",
+            intended_sentence,
+            best_text,
+            intended_translit,
+            actual_translit,
+            word_diff,
+            char_diff
+        )
+        
+    except Exception as e:
+        error_msg = f"❌ Unexpected error: {str(e)}"
+        print(f"{error_msg}")
+        print(f"🔍 Full traceback: {traceback.format_exc()}")
+        return (error_msg, "", "", "", "", "", "", "", "", "", "")
 
 # ---------------- UI ---------------- #
 def create_interface():
@@ -555,21 +502,18 @@ def create_interface():
         
         **Perfect your pronunciation in English, Tamil, Malayalam, and Hindi!**
         
-        This tool uses specialized AI models to give you detailed feedback on your pronunciation,
-        including transliteration to help you understand exactly where you need improvement.
-        
-        ### How to use:
+        ### 🚀 How to use:
         1. 🌐 Select your target language
         2. 🎲 Generate a practice sentence  
-        3. 🎤 Record yourself saying the sentence clearly
-        4. 🔍 Get detailed pronunciation analysis with transliteration
+        3. 🎤 Record yourself clearly (at least 0.5 seconds)
+        4. 🔍 Get detailed analysis with visual feedback
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
                 language_dropdown = gr.Dropdown(
                     choices=list(LANG_CODES.keys()),
-                    value="Tamil",
+                    value="English",  # Start with English for reliability
                     label="🌐 Select Language"
                 )
             with gr.Column(scale=1):
@@ -585,29 +529,28 @@ def create_interface():
         audio_input = gr.Audio(
             sources=["microphone", "upload"],
             type="filepath", 
-            label="🎤 Record Your Pronunciation"
+            label="🎤 Record Your Pronunciation (speak clearly for at least 0.5 seconds)"
         )
         
         analyze_btn = gr.Button("🔍 Analyze Pronunciation", variant="secondary", size="lg")
         
-        with gr.Row():
-            status_output = gr.Textbox(
-                label="📊 Analysis Results",
-                interactive=False,
-                lines=8
-            )
+        status_output = gr.Textbox(
+            label="📊 Analysis Results",
+            interactive=False,
+            lines=10
+        )
         
-        with gr.Accordion("🤖 Model Outputs", open=False):
+        with gr.Accordion("🤖 Model Outputs (Debug Info)", open=False):
             with gr.Row():
-                primary_output = gr.Textbox(label="Primary Model (IndicWhisper)", interactive=False)
-                specialized_output = gr.Textbox(label="Specialized Model", interactive=False)
+                primary_output = gr.Textbox(label="Primary Model Output", interactive=False)
+                specialized_output = gr.Textbox(label="Specialized Model Output", interactive=False)
         
         with gr.Accordion("📈 Detailed Metrics", open=False):
             with gr.Row():
                 wer_output = gr.Textbox(label="Word Error Rate", interactive=False)
                 cer_output = gr.Textbox(label="Character Error Rate", interactive=False)
         
-        gr.Markdown("### 🔍 Detailed Comparison")
+        gr.Markdown("### 🔍 Side-by-Side Comparison")
         
         with gr.Row():
             with gr.Column():
@@ -619,8 +562,8 @@ def create_interface():
                 intended_translit = gr.Textbox(label="🎯 Target (Romanized)", interactive=False) 
                 actual_translit = gr.Textbox(label="🗣️ What You Said (Romanized)", interactive=False)
         
-        gr.Markdown("### 🎨 Visual Comparison")
-        gr.Markdown("**Green** = Correct, **Red** = Wrong/Missing, **Orange** = Added/Substituted")
+        gr.Markdown("### 🎨 Visual Feedback")
+        gr.Markdown("**🟢 Green** = Correct | **🔴 Red** = Wrong/Missing | **🟠 Orange** = Added/Substituted")
         
         word_diff_html = gr.HTML(label="🔤 Word-by-Word Comparison")
         char_diff_html = gr.HTML(label="🔍 Character-by-Character Analysis")
@@ -649,22 +592,13 @@ def create_interface():
         )
         
         gr.Markdown("""
-        ### 📚 Pro Tips for Better Pronunciation:
-        
-        - **Speak slowly and clearly** - Don't rush through the sentence
-        - **Pronounce each syllable** - Break down complex words
-        - **Check the romanized version** - Use it to understand correct pronunciation
-        - **Practice repeatedly** - Use the same sentence multiple times to track improvement
-        - **Focus on problem areas** - Pay attention to red-highlighted parts
-        - **Record in a quiet environment** - Minimize background noise
-        
-        ### 🎯 Understanding the Feedback:
-        
-        - **Green highlights** = Perfect pronunciation ✅
-        - **Red highlights** = Missing or mispronounced ❌  
-        - **Orange highlights** = Added or substituted 🔄
-        - **Transliteration** = Helps you see pronunciation patterns
-        - **Error rates** = Lower is better (0% = perfect)
+        ### 🔧 Troubleshooting:
+        
+        - **"Audio too short"** → Record for at least 0.5 seconds
+        - **"Model loading failed"** → Try refreshing the page  
+        - **"Empty transcription"** → Speak louder and clearer
+        - **Script mismatch** → Make sure you're speaking the correct language
+        - **General errors** → Check the debug info section for details
         """)
     
     return demo
@@ -672,10 +606,16 @@ def create_interface():
 # ---------------- LAUNCH ---------------- #
 if __name__ == "__main__":
     print("🚀 Starting Enhanced Pronunciation Comparator...")
+    print("🔧 System Check:")
+    print(f"   - PyTorch: {torch.__version__}")
+    print(f"   - Device: {DEVICE}")
+    print(f"   - Transliteration: {'✅' if INDIC_OK else '❌'}")
+    
     demo = create_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=True,
-        show_error=True
+        show_error=True,
+        debug=True  # Enable debug mode for better error reporting
     )