Update app.py

app.py

@@ -1,78 +1,90 @@
 import gradio as gr
 from transformers import pipeline
+import torch
 
-def create_tone_analyzer():
-    """Initialize the speech-to-text and tone analysis models"""
+def load_models():
+    """Load and verify models with error checking"""
     try:
-        # Load Whisper for speech recognition
+        # Check CUDA availability
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {device}")
+        
+        # Load a smaller Whisper model for better compatibility
         transcriber = pipeline(
-            "automatic-speech-recognition", 
-            model="openai/whisper-small"
+            "automatic-speech-recognition",
+            model="openai/whisper-tiny",
+            device=device
         )
         
-        # Load RoBERTa for tone analysis
-        tone_analyzer = pipeline(
+        # Load a simpler sentiment model
+        sentiment = pipeline(
             "sentiment-analysis",
-            model="cardiffnlp/twitter-roberta-base-sentiment-latest"
+            model="distilbert-base-uncased-finetuned-sst-2-english",
+            device=device
         )
         
-        return transcriber, tone_analyzer
+        return transcriber, sentiment
     except Exception as e:
-        raise RuntimeError(f"Failed to load models: {str(e)}")
+        print(f"Error loading models: {str(e)}")
+        return None, None
 
-def analyze_tone(audio_file):
-    """Analyze the tone of speech"""
-    try:
-        transcriber, tone_analyzer = create_tone_analyzer()
-        
-        # Convert speech to text
-        text = transcriber(audio_file)["text"]
-        
-        # Analyze tone
-        result = tone_analyzer(text)[0]
-        
-        # Convert model output to human-readable format
-        tone_mapping = {
-            'LABEL_0': 'Negative',
-            'LABEL_1': 'Neutral',
-            'LABEL_2': 'Positive'
-        }
-        
-        tone = tone_mapping.get(result['label'], result['label'])
-        confidence = result['score']
-        
-        return {
-            "tone": f"{tone}",
-            "confidence": f"{confidence:.1%}"
-        }
+def analyze_audio(audio_path):
+    """
+    Analyze audio tone with robust error handling
+    """
+    if audio_path is None:
+        return "Please provide an audio input", "No audio detected"
         
+    try:
+        # Load models
+        transcriber, sentiment = load_models()
+        if transcriber is None or sentiment is None:
+            return "Error loading models", "Model initialization failed"
+            
+        # Transcribe with error checking
+        try:
+            result = transcriber(audio_path)
+            text = result["text"]
+            if not text.strip():
+                return "No speech detected", "Empty transcription"
+        except Exception as e:
+            return f"Transcription error: {str(e)}", "Failed to process audio"
+            
+        # Analyze sentiment
+        try:
+            sentiment_result = sentiment(text)[0]
+            tone = sentiment_result["label"]
+            confidence = f"{sentiment_result['score']:.2%}"
+            return tone, confidence
+        except Exception as e:
+            return f"Sentiment analysis error: {str(e)}", "Analysis failed"
+            
     except Exception as e:
-        return {
-            "tone": "Error",
-            "confidence": f"Failed to analyze: {str(e)}"
-        }
+        return f"Unexpected error: {str(e)}", "Process failed"
 
-def create_interface():
-    """Create the Gradio interface"""
-    return gr.Interface(
-        fn=analyze_tone,
-        inputs=gr.Audio(
-            sources=["microphone", "upload"],
-            type="filepath",
-            label="Record or Upload Audio"
-        ),
-        outputs=[
-            gr.Textbox(label="Detected Tone"),
-            gr.Textbox(label="Confidence")
-        ],
-        title="Speech Tone Analyzer",
-        description="Record or upload audio to analyze its emotional tone.",
-        theme=gr.themes.Soft()
-    )
+# Create interface with simplified components
+interface = gr.Interface(
+    fn=analyze_audio,
+    inputs=gr.Audio(
+        sources=["microphone", "upload"],
+        type="filepath",
+    ),
+    outputs=[
+        gr.Textbox(label="Tone"),
+        gr.Textbox(label="Confidence Level")
+    ],
+    title="Simple Speech Tone Analyzer",
+    description="Record or upload audio to analyze its tone. The analysis may take a few moments.",
+    examples=None,
+    cache_examples=False,
+    theme=gr.themes.Base(),
+)
 
+# Launch with specific parameters for better stability
 if __name__ == "__main__":
-    interface = create_interface()
     interface.launch(
-        share=True,
-        server_name="0.0.0.0"
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
     )