Update app.py

app.py

@@ -4,618 +4,229 @@ import difflib
 import re
 import jiwer
 import torch
-import warnings
-import contextlib
-import traceback
-import gc
-from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq, pipeline
-import librosa
-import numpy as np
-
-# Optional transliteration
-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. 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")
+from transformers import WhisperForConditionalGeneration, WhisperProcessor
+from indic_transliteration import sanscript
+from indic_transliteration.sanscript import transliterate
 
 # ---------------- CONFIG ---------------- #
 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"🔧 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")
+# Updated model configurations for each language
+MODEL_CONFIGS = {
+    "English": "openai/whisper-large-v2",
+    "Tamil": "vasista22/whisper-tamil-large-v2", 
+    "Malayalam": "thennal/whisper-medium-ml"
+}
 
 LANG_CODES = {
     "English": "en",
     "Tamil": "ta", 
-    "Malayalam": "ml",
-    "Hindi": "hi"
+    "Malayalam": "ml"
 }
 
-# Simplified model setup - use only reliable models
-SPECIALIZED_MODELS = {
-    "English": "openai/whisper-base.en",
-    "Tamil": "openai/whisper-large-v2",  # More reliable fallback
-    "Malayalam": "openai/whisper-large-v2",  # More reliable fallback  
-    "Hindi": "openai/whisper-large-v2"
+LANG_PRIMERS = {
+    "English": ("The transcript should be in English only.",
+                "Write only in English without translation. Example: This is an English sentence."),
+    "Tamil": ("நகல் தமிழ் எழுத்துக்களில் மட்டும் இருக்க வேண்டும்.",
+              "தமிழ் எழுத்துக்களில் மட்டும் எழுதவும், மொழிபெயர்ப்பு செய்யக்கூடாது. உதாரணம்: இது ஒரு தமிழ் வாக்கியம்."),
+    "Malayalam": ("ട്രാൻസ്ഖ്രിപ്റ്റ് മലയാള ലിപിയിൽ ആയിരിക്കണം.",
+                  "മലയാള ലിപിയിൽ മാത്രം എഴുതുക, വിവർത്തനം ചെയ്യരുത്. ഉദാഹരണം: ഇതൊരു മലയാള വാക്യമാണ്. എനിക്ക് മലയാളം അറിയാം.")
 }
 
 SCRIPT_PATTERNS = {
     "Tamil": re.compile(r"[஀-௿]"),
-    "Malayalam": re.compile(r"[ഀ-ൿ]"),
-    "Hindi": re.compile(r"[ऀ-ॿ]"),
+    "Malayalam": re.compile(r"[ഀ-ൿ]"), 
     "English": re.compile(r"[A-Za-z]")
 }
 
-# Transliteration mappings
-TRANSLITERATION_SCRIPTS = {
-    "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
-}
-
 SENTENCE_BANK = {
     "English": [
         "The sun sets over the horizon.",
-        "Learning languages is fun and rewarding.",
+        "Learning languages is fun.",
         "I like to drink coffee in the morning.",
-        "Technology helps us connect with others.",
+        "Technology helps us communicate better.",
         "Reading books expands our knowledge."
     ],
     "Tamil": [
         "இன்று நல்ல வானிலை உள்ளது.",
         "நான் தமிழ் கற்றுக்கொண்டு இருக்கிறேன்.",
         "எனக்கு புத்தகம் படிக்க விருப்பம்.",
-        "காலையில் காபி குடிக்க பிடிக்கும்.",
-        "நண்பர்களுடன் பேசுவது மகிழ்ச்சி."
+        "தமிழ் மொழி மிகவும் அழகானது.",
+        "நான் தினமும் பள்ளிக்கு செல்கிறேன்."
     ],
     "Malayalam": [
         "എനിക്ക് മലയാളം വളരെ ഇഷ്ടമാണ്.",
         "ഇന്ന് മഴപെയ്യുന്നു.",
         "ഞാൻ പുസ്തകം വായിക്കുന്നു.",
-        "കാലയിൽ ചായ കുടിക്കാൻ ഇഷ്ടമാണ്.",
-        "സുഹൃത്തുക്കളോടു സംസാരിക്കുന്നത് സന്തോഷമാണ്."
-    ],
-    "Hindi": [
-        "आज मौसम अच्छा है।",
-        "मुझे हिंदी बोलना पसंद है।",
-        "मैं किताब पढ़ रहा हूँ।",
-        "सुबह चाय पीना अच्छा लगता है।",
-        "दोस्तों के साथ बात करना खुशी देता है।"
+        "കേരളം എന്റെ സ്വന്തം നാടാണ്.",
+        "ഞാൻ മലയാളം പഠിക്കുന്നു."
     ]
 }
 
-# Model cache
-models = {}
+# ---------------- LOAD MODELS ---------------- #
+print("Loading Whisper models...")
+whisper_models = {}
+whisper_processors = {}
+
+for lang, model_id in MODEL_CONFIGS.items():
+    print(f"Loading {lang} model: {model_id}")
+    whisper_models[lang] = WhisperForConditionalGeneration.from_pretrained(model_id).to(DEVICE)
+    whisper_processors[lang] = WhisperProcessor.from_pretrained(model_id)
 
-# ---------------- 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
+print("All models loaded successfully!")
 
+# ---------------- HELPERS ---------------- #
 def get_random_sentence(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"""
-    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"""
-    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:
-            return transliterate(text, source_script, sanscript.HK)
-        else:
-            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 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, "Empty audio file"
-        
-        # Normalize audio
-        audio = audio.astype(np.float32)
-        max_val = np.max(np.abs(audio))
-        if max_val > 0:
-            audio = audio / max_val
-        
-        # Trim silence
-        audio, _ = librosa.effects.trim(audio, top_db=20)
-        
-        # 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:
-        error_msg = f"Audio preprocessing failed: {str(e)}"
-        print(f"❌ {error_msg}")
-        return None, error_msg
-
-# ---------------- 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}"
+    return random.choice(SENTENCE_BANK[language_choice])
+
+def is_script(text, lang_name):
+    pattern = SCRIPT_PATTERNS.get(lang_name)
+    return bool(pattern.search(text)) if pattern else True
+
+def transliterate_to_hk(text, lang_choice):
+    mapping = {
+        "Tamil": sanscript.TAMIL,
+        "Malayalam": sanscript.MALAYALAM,
+        "English": None
+    }
+    return transliterate(text, mapping[lang_choice], sanscript.HK) if mapping[lang_choice] else text
+
+def transcribe_once(audio_path, language_choice, initial_prompt, beam_size, temperature, condition_on_previous_text):
+    # Get the appropriate model and processor for the language
+    model = whisper_models[language_choice]
+    processor = whisper_processors[language_choice]
+    lang_code = LANG_CODES[language_choice]
     
-    if model_key in models:
-        print(f"✅ Using cached model: {model_key}")
-        return models[model_key], None
+    # Load and process audio
+    import librosa
+    audio, sr = librosa.load(audio_path, sr=16000)
     
-    try:
-        print(f"🔄 Loading model: {model_name}")
-        
-        # 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=model_name,
-            device=DEVICE_INDEX,
-            torch_dtype=DTYPE,
-            return_timestamps=False
-        )
-        
-        models[model_key] = pipeline_model
-        print(f"✅ Model loaded successfully: {model_name}")
-        return pipeline_model, None
-        
-    except Exception as e:
-        error_msg = f"Failed to load {model_name}: {str(e)}"
-        print(f"❌ {error_msg}")
-        return None, error_msg
-
-# ---------------- TRANSCRIPTION ---------------- #
-def transcribe_audio_safe(audio_path, model_name, language):
-    """Safe transcription with comprehensive error handling"""
-    try:
-        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
-        }
-        
-        # Try to set language (some models support this)
-        try:
-            if hasattr(model, "model") and hasattr(model, "tokenizer"):
-                forced_ids = model.tokenizer.get_decoder_prompt_ids(
-                    language=lang_code, 
-                    task="transcribe"
-                )
-                if forced_ids:
-                    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 = model(audio_path, generate_kwargs=generate_kwargs)
-        
-        if isinstance(result, dict):
-            text = result.get("text", "").strip()
-        else:
-            text = str(result).strip()
-        
-        print(f"✅ Transcription complete: '{text[:50]}...'")
-        return text, None
-        
-    except Exception as 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_safe(reference, hypothesis):
-    """Compute WER and CER with error handling"""
-    try:
-        ref_clean = reference.strip()
-        hyp_clean = hypothesis.strip()
-        
-        if not ref_clean or not hyp_clean:
-            return 1.0, 1.0, "Empty text"
-        
-        wer = jiwer.wer(ref_clean, hyp_clean)
-        cer = jiwer.cer(ref_clean, hyp_clean)
-        
-        return wer, cer, None
-    except Exception as e:
-        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"""
-    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 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 with comprehensive error handling"""
+    # Process audio with the specific model's processor
+    input_features = processor(audio, sampling_rate=16000, return_tensors="pt").input_features.to(DEVICE)
     
-    print(f"\n🔍 Starting pronunciation analysis...")
-    print(f"📝 Language: {language_choice}")
-    print(f"🎯 Target: {intended_sentence[:50]}...")
+    # Generate forced decoder ids for the language
+    forced_decoder_ids = processor.get_decoder_prompt_ids(language=lang_code, task="transcribe")
     
-    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!
+    # Generate transcription
+    with torch.no_grad():
+        predicted_ids = model.generate(
+            input_features,
+            forced_decoder_ids=forced_decoder_ids,
+            max_length=448,
+            num_beams=beam_size,
+            temperature=temperature if temperature > 0 else None,
+            do_sample=temperature > 0,
+        )
+    
+    # Decode the transcription
+    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+    return transcription.strip()
+
+def highlight_differences(ref, hyp):
+    ref_words, hyp_words = ref.strip().split(), hyp.strip().split()
+    sm = difflib.SequenceMatcher(None, ref_words, hyp_words)
+    out_html = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == 'equal':
+            out_html.extend([f"<span style='color:green'>{w}</span>" for w in ref_words[i1:i2]])
+        elif tag == 'replace':
+            out_html.extend([f"<span style='color:red'>{w}</span>" for w in ref_words[i1:i2]])
+            out_html.extend([f"<span style='color:orange'>{w}</span>" for w in hyp_words[j1:j2]])
+        elif tag == 'delete':
+            out_html.extend([f"<span style='color:red;text-decoration:line-through'>{w}</span>" for w in ref_words[i1:i2]])
+        elif tag == 'insert':
+            out_html.extend([f"<span style='color:orange'>{w}</span>" for w in hyp_words[j1:j2]])
+    return " ".join(out_html)
+
+def char_level_highlight(ref, hyp):
+    sm = difflib.SequenceMatcher(None, list(ref), list(hyp))
+    out = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == 'equal':
+            out.extend([f"<span style='color:green'>{c}</span>" for c in ref[i1:i2]])
+        elif tag in ('replace', 'delete'):
+            out.extend([f"<span style='color:red;text-decoration:underline'>{c}</span>" for c in ref[i1:i2]])
+        elif tag == 'insert':
+            out.extend([f"<span style='color:orange'>{c}</span>" for c in hyp[j1:j2]])
+    return "".join(out)
+
+# ---------------- MAIN ---------------- #
+def compare_pronunciation(audio, language_choice, intended_sentence,
+                          pass1_beam, pass1_temp, pass1_condition):
+    if audio is None or not intended_sentence.strip():
+        return ("No audio or intended sentence.", "", "", "", "", "", "", "")
+
+    primer_weak, primer_strong = LANG_PRIMERS[language_choice]
+
+    # Pass 1: raw transcription with user-configured decoding parameters
+    actual_text = transcribe_once(audio, language_choice, primer_weak,
+                                  pass1_beam, pass1_temp, pass1_condition)
+
+    # Pass 2: strict transcription biased by intended sentence (fixed decoding params)
+    strict_prompt = f"{primer_strong}\nTarget: {intended_sentence}"
+    corrected_text = transcribe_once(audio, language_choice, strict_prompt,
+                                     beam_size=5, temperature=0.0, condition_on_previous_text=False)
+
+    # Compute WER and CER
+    wer_val = jiwer.wer(intended_sentence, actual_text)
+    cer_val = jiwer.cer(intended_sentence, actual_text)
+
+    # Transliteration of Pass 1 output
+    hk_translit = transliterate_to_hk(actual_text, language_choice) if is_script(actual_text, language_choice) else f"[Script mismatch: expected {language_choice}]"
+
+    # Highlight word-level and character-level differences
+    diff_html = highlight_differences(intended_sentence, actual_text)
+    char_html = char_level_highlight(intended_sentence, actual_text)
+
+    return (actual_text, corrected_text, hk_translit, f"{wer_val:.2f}", f"{cer_val:.2f}",
+            diff_html, char_html, intended_sentence)
 
-{score}
-{feedback}
+# ---------------- UI ---------------- #
+with gr.Blocks(title="Pronunciation Comparator") as demo:
+    gr.Markdown("## 🎙 Pronunciation Comparator - English, Tamil & Malayalam")
+    gr.Markdown("Practice pronunciation with specialized Whisper models for each language!")
 
-🤖 Best result from: {best_source}
-📊 Word Accuracy: {(1-wer)*100:.1f}%
-📈 Character Accuracy: {(1-cer)*100:.1f}%
+    with gr.Row():
+        lang_choice = gr.Dropdown(choices=list(LANG_CODES.keys()), value="Malayalam", label="Language")
+        gen_btn = gr.Button("🎲 Generate Sentence")
 
-🔍 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, "", "", "", "", "", "", "", "", "", "")
+    intended_display = gr.Textbox(label="Generated Sentence (Read aloud)", interactive=False)
 
-# ---------------- UI ---------------- #
-def create_interface():
-    with gr.Blocks(title="Enhanced Pronunciation Comparator", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🎙️ Enhanced Pronunciation Comparator
-        
-        **Perfect your pronunciation in English, Tamil, Malayalam, and Hindi!**
-        
-        ### 🚀 How to use:
-        1. 🌐 Select your target language
-        2. 🎲 Generate a practice sentence  
-        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="English",  # Start with English for reliability
-                    label="🌐 Select Language"
-                )
-            with gr.Column(scale=1):
-                generate_btn = gr.Button("🎲 Generate Practice Sentence", variant="primary")
-        
-        intended_textbox = gr.Textbox(
-            label="📝 Practice Sentence",
-            interactive=False,
-            lines=2,
-            placeholder="Click 'Generate Practice Sentence' to get started..."
-        )
-        
-        audio_input = gr.Audio(
-            sources=["microphone", "upload"],
-            type="filepath", 
-            label="🎤 Record Your Pronunciation (speak clearly for at least 0.5 seconds)"
-        )
+    with gr.Row():
+        audio_input = gr.Audio(sources=["microphone", "upload"], type="filepath", label="Record your pronunciation")
         
-        analyze_btn = gr.Button("🔍 Analyze Pronunciation", variant="secondary", size="lg")
-        
-        status_output = gr.Textbox(
-            label="📊 Analysis Results",
-            interactive=False,
-            lines=10
-        )
-        
-        with gr.Accordion("🤖 Model Outputs (Debug Info)", open=False):
-            with gr.Row():
-                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("### 🔍 Side-by-Side Comparison")
-        
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("#### 📝 Original Script")
-                intended_orig = gr.Textbox(label="🎯 Target Text", interactive=False)
-                actual_orig = gr.Textbox(label="🗣️ What You Said", interactive=False)
-            with gr.Column():
-                gr.Markdown("#### 🔤 Romanized (Transliterated)")
-                intended_translit = gr.Textbox(label="🎯 Target (Romanized)", interactive=False) 
-                actual_translit = gr.Textbox(label="🗣️ What You Said (Romanized)", interactive=False)
-        
-        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")
-        
-        # Event handlers
-        generate_btn.click(
-            fn=get_random_sentence,
-            inputs=[language_dropdown],
-            outputs=[intended_textbox]
-        )
-        
-        analyze_btn.click(
-            fn=compare_pronunciation,
-            inputs=[audio_input, language_dropdown, intended_textbox],
-            outputs=[
-                status_output, primary_output, specialized_output,
-                wer_output, cer_output, intended_orig, actual_orig,
-                intended_translit, actual_translit, word_diff_html, char_diff_html
-            ]
-        )
-        
-        language_dropdown.change(
-            fn=get_random_sentence,
-            inputs=[language_dropdown], 
-            outputs=[intended_textbox]
-        )
-        
-        gr.Markdown("""
-        ### 🔧 Troubleshooting:
+    with gr.Column():
+        gr.Markdown("### Transcription Parameters")
+        pass1_beam = gr.Slider(1, 10, value=8, step=1, label="Pass 1 Beam Size")
+        pass1_temp = gr.Slider(0.0, 1.0, value=0.4, step=0.1, label="Pass 1 Temperature")
+        pass1_condition = gr.Checkbox(value=True, label="Pass 1: Condition on previous text")
+
+    submit_btn = gr.Button("🔍 Analyze Pronunciation", variant="primary")
+
+    with gr.Row():
+        pass1_out = gr.Textbox(label="Pass 1: What You Actually Said")
+        pass2_out = gr.Textbox(label="Pass 2: Target-Biased Output")
         
-        - **"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
+    with gr.Row():
+        hk_out = gr.Textbox(label="Harvard-Kyoto Transliteration (Pass 1)")
+        wer_out = gr.Textbox(label="Word Error Rate")
+        cer_out = gr.Textbox(label="Character Error Rate")
+
+    gr.Markdown("### Visual Feedback")
+    diff_html_box = gr.HTML(label="Word Differences Highlighted")
+    char_html_box = gr.HTML(label="Character-Level Highlighting (mispronounced = red underline)")
+
+    # Event handlers
+    gen_btn.click(fn=get_random_sentence, inputs=[lang_choice], outputs=[intended_display])
+
+    submit_btn.click(
+        fn=compare_pronunciation,
+        inputs=[audio_input, language_choice, intended_display, pass1_beam, pass1_temp, pass1_condition],
+        outputs=[
+            pass1_out, pass2_out, hk_translit, wer_out, cer_out,
+            diff_html_box, char_html_box, intended_display
+        ]
+    )
 
-# ---------------- 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,
-        debug=True  # Enable debug mode for better error reporting
-    )
+    demo.launch()