Upd ASR loader

config.py

@@ -54,8 +54,8 @@ DESCRIPTION = """
 <p>📄 <strong>Document RAG:</strong> Answer based on uploaded medical documents</p>
 <p>🌐 <strong>Web Search:</strong> Fetch knowledge from reliable online medical resources</p>
 <p>🌍 <strong>Multi-language:</strong> Automatic translation for non-English queries</p>
-<p>Tips: Customise configurations, system prompt to see the magic happens!</p>
-<p>Note: Case GPU aborted or MedSwin not ready, please select another model!</p>
+<p><strong>Tips:</strong> Customise configurations & system prompt to see the magic!</p>
+<p><strong>Note:</strong> Case GPU aborted or MedSwin not ready, please try another model!</p>
 </center>
 """
 CSS = """

voice.py

@@ -92,7 +92,7 @@ def transcribe_audio_whisper(audio_path: str) -> str:
             except Exception as e:
                 logger.error(f"[ASR] Error initializing Whisper model: {e}")
                 import traceback
-                logger.debug(f"[ASR] Full traceback: {traceback.format_exc()}")
+                logger.error(f"[ASR] Initialization traceback: {traceback.format_exc()}")
                 return ""
         
         if config.global_whisper_model is None:
@@ -106,44 +106,106 @@ def transcribe_audio_whisper(audio_path: str) -> str:
         logger.info("[ASR] Loading audio file...")
         # Load audio using torchaudio (imported from models)
         from models import torchaudio
+        import torch
         if torchaudio is None:
             logger.error("[ASR] torchaudio not available")
             return ""
         
-        waveform, sample_rate = torchaudio.load(audio_path)
-        # Resample to 16kHz if needed (Whisper expects 16kHz)
-        if sample_rate != 16000:
-            resampler = torchaudio.transforms.Resample(sample_rate, 16000)
-            waveform = resampler(waveform)
-            sample_rate = 16000
-        
-        logger.info("[ASR] Processing audio with Whisper...")
-        # Process audio
-        inputs = processor(waveform.squeeze().numpy(), sampling_rate=sample_rate, return_tensors="pt")
-        
-        # Move inputs to same device as model
-        device = next(model.parameters()).device
-        inputs = {k: v.to(device) for k, v in inputs.items()}
-        
-        logger.info("[ASR] Running Whisper transcription...")
-        # Generate transcription
-        with torch.no_grad():
-            generated_ids = model.generate(**inputs)
-        
-        # Decode transcription
-        transcribed_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
-        
-        if transcribed_text:
-            logger.info(f"[ASR] ✅ Transcription successful: {transcribed_text[:100]}...")
-            logger.info(f"[ASR] Transcription length: {len(transcribed_text)} characters")
-        else:
-            logger.warning("[ASR] Whisper returned empty transcription")
+        # Check if audio file exists
+        if not os.path.exists(audio_path):
+            logger.error(f"[ASR] Audio file not found: {audio_path}")
+            return ""
         
-        return transcribed_text
+        try:
+            waveform, sample_rate = torchaudio.load(audio_path)
+            logger.info(f"[ASR] Loaded audio: shape={waveform.shape}, sample_rate={sample_rate}")
+            
+            # Ensure audio is mono (single channel)
+            if waveform.shape[0] > 1:
+                logger.info(f"[ASR] Converting {waveform.shape[0]}-channel audio to mono")
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+            
+            # Resample to 16kHz if needed (Whisper expects 16kHz)
+            if sample_rate != 16000:
+                logger.info(f"[ASR] Resampling from {sample_rate}Hz to 16000Hz")
+                resampler = torchaudio.transforms.Resample(sample_rate, 16000)
+                waveform = resampler(waveform)
+                sample_rate = 16000
+            
+            logger.info(f"[ASR] Audio ready: shape={waveform.shape}, sample_rate={sample_rate}")
+            
+            logger.info("[ASR] Processing audio with Whisper processor...")
+            # Process audio - convert to numpy and ensure it's the right shape
+            audio_array = waveform.squeeze().numpy()
+            logger.info(f"[ASR] Audio array shape: {audio_array.shape}, dtype: {audio_array.dtype}")
+            
+            # Process audio
+            inputs = processor(audio_array, sampling_rate=sample_rate, return_tensors="pt")
+            logger.info(f"[ASR] Processor inputs: {list(inputs.keys())}")
+            
+            # Move inputs to same device as model
+            device = next(model.parameters()).device
+            logger.info(f"[ASR] Model device: {device}")
+            inputs = {k: v.to(device) for k, v in inputs.items()}
+            
+            logger.info("[ASR] Running Whisper model.generate()...")
+            # Generate transcription with proper parameters
+            # Whisper expects input_features as the main parameter
+            if "input_features" not in inputs:
+                logger.error(f"[ASR] Missing input_features in processor output. Keys: {list(inputs.keys())}")
+                return ""
+            
+            input_features = inputs["input_features"]
+            logger.info(f"[ASR] Input features shape: {input_features.shape}, dtype: {input_features.dtype}")
+            
+            with torch.no_grad():
+                try:
+                    # Whisper generate with proper parameters
+                    generated_ids = model.generate(
+                        input_features,
+                        max_length=448,  # Whisper default max length
+                        num_beams=5,
+                        language=None,  # Auto-detect language
+                        task="transcribe",
+                        return_timestamps=False
+                    )
+                    logger.info(f"[ASR] Generated IDs shape: {generated_ids.shape}, dtype: {generated_ids.dtype}")
+                    logger.info(f"[ASR] Generated IDs sample: {generated_ids[0][:20] if len(generated_ids) > 0 else 'empty'}")
+                except Exception as gen_error:
+                    logger.error(f"[ASR] Error in model.generate(): {gen_error}")
+                    import traceback
+                    logger.error(f"[ASR] Generate traceback: {traceback.format_exc()}")
+                    # Try simpler generation without optional parameters
+                    logger.info("[ASR] Retrying with minimal parameters...")
+                    try:
+                        generated_ids = model.generate(input_features)
+                        logger.info(f"[ASR] Retry successful, generated IDs shape: {generated_ids.shape}")
+                    except Exception as retry_error:
+                        logger.error(f"[ASR] Retry also failed: {retry_error}")
+                        return ""
+            
+            logger.info("[ASR] Decoding transcription...")
+            # Decode transcription
+            transcribed_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
+            
+            if transcribed_text:
+                logger.info(f"[ASR] ✅ Transcription successful: {transcribed_text[:100]}...")
+                logger.info(f"[ASR] Transcription length: {len(transcribed_text)} characters")
+            else:
+                logger.warning("[ASR] Whisper returned empty transcription")
+                logger.warning(f"[ASR] Generated IDs: {generated_ids}")
+                logger.warning(f"[ASR] Decoded (before strip): {processor.batch_decode(generated_ids, skip_special_tokens=False)[0]}")
+            
+            return transcribed_text
+        except Exception as audio_error:
+            logger.error(f"[ASR] Error processing audio file: {audio_error}")
+            import traceback
+            logger.error(f"[ASR] Audio processing traceback: {traceback.format_exc()}")
+            return ""
     except Exception as e:
         logger.error(f"[ASR] Whisper transcription error: {e}")
         import traceback
-        logger.debug(f"[ASR] Full traceback: {traceback.format_exc()}")
+        logger.error(f"[ASR] Full traceback: {traceback.format_exc()}")
         return ""
 
 def transcribe_audio(audio):