Update app.py

app.py

@@ -1,116 +1,78 @@
 import gradio as gr
 from transformers import pipeline
-import numpy as np
 
-def create_speech_analyzer():
-    """Initialize the speech-to-text and sentiment analysis models"""
+def create_tone_analyzer():
+    """Initialize the speech-to-text and tone analysis models"""
     try:
-        # Load Faster Whisper for improved speech recognition
+        # Load Whisper for speech recognition
         transcriber = pipeline(
             "automatic-speech-recognition", 
-            model="openai/whisper-small",  # Using smaller model for faster processing
-            max_new_tokens=128
+            model="openai/whisper-small"
         )
         
-        # Load RoBERTa model for more nuanced sentiment analysis
-        sentiment_model = pipeline(
+        # Load RoBERTa for tone analysis
+        tone_analyzer = pipeline(
             "sentiment-analysis",
             model="cardiffnlp/twitter-roberta-base-sentiment-latest"
         )
         
-        return transcriber, sentiment_model
-    
+        return transcriber, tone_analyzer
     except Exception as e:
-        raise RuntimeError(f"Error loading models: {str(e)}")
+        raise RuntimeError(f"Failed to load models: {str(e)}")
 
-def analyze_speech(audio_file):
-    """
-    Analyze speech for transcription and emotional content.
-    Returns both the transcription and detailed sentiment analysis.
-    """
+def analyze_tone(audio_file):
+    """Analyze the tone of speech"""
     try:
-        transcriber, sentiment_model = create_speech_analyzer()
+        transcriber, tone_analyzer = create_tone_analyzer()
         
-        # Get transcription
-        transcription = transcriber(audio_file)["text"]
+        # Convert speech to text
+        text = transcriber(audio_file)["text"]
         
-        # RoBERTa provides more detailed sentiment analysis
-        sentiment_result = sentiment_model(transcription)[0]
+        # Analyze tone
+        result = tone_analyzer(text)[0]
         
-        # Map sentiment labels to more readable format
-        sentiment_mapping = {
+        # Convert model output to human-readable format
+        tone_mapping = {
             'LABEL_0': 'Negative',
             'LABEL_1': 'Neutral',
             'LABEL_2': 'Positive'
         }
         
-        # Get the sentiment label and score
-        sentiment = sentiment_mapping.get(sentiment_result['label'], sentiment_result['label'])
-        confidence = sentiment_result['score']
-        
-        # Analyze sentiment of smaller chunks for longer texts
-        if len(transcription.split()) > 50:
-            # Split into sentences or chunks
-            chunks = transcription.split('.')
-            chunk_sentiments = [sentiment_model(chunk)[0] for chunk in chunks if len(chunk.strip()) > 0]
-            
-            # Calculate average sentiment
-            avg_sentiment = np.mean([s['score'] for s in chunk_sentiments])
-            sentiment_variation = np.std([s['score'] for s in chunk_sentiments])
-            
-            detailed_analysis = (
-                f"Overall Sentiment: {sentiment} ({confidence:.2%})\n"
-                f"Sentiment Stability: {1 - sentiment_variation:.2%}\n"
-                f"Text chunks analyzed: {len(chunk_sentiments)}"
-            )
-        else:
-            detailed_analysis = f"Sentiment: {sentiment} ({confidence:.2%})"
+        tone = tone_mapping.get(result['label'], result['label'])
+        confidence = result['score']
         
         return {
-            "transcription": transcription,
-            "sentiment": sentiment,
-            "analysis": detailed_analysis
+            "tone": f"{tone}",
+            "confidence": f"{confidence:.1%}"
         }
         
     except Exception as e:
         return {
-            "transcription": f"Error in processing: {str(e)}",
-            "sentiment": "ERROR",
-            "analysis": "Analysis failed"
+            "tone": "Error",
+            "confidence": f"Failed to analyze: {str(e)}"
         }
 
 def create_interface():
-    """Create and configure the Gradio interface"""
+    """Create the Gradio interface"""
     return gr.Interface(
-        fn=analyze_speech,
+        fn=analyze_tone,
         inputs=gr.Audio(
             sources=["microphone", "upload"],
             type="filepath",
-            label="Upload or Record Audio"
+            label="Record or Upload Audio"
         ),
         outputs=[
-            gr.Textbox(label="Transcription", lines=3),
-            gr.Textbox(label="Sentiment"),
-            gr.Textbox(label="Detailed Analysis", lines=3)
+            gr.Textbox(label="Detected Tone"),
+            gr.Textbox(label="Confidence")
         ],
-        title="Advanced Speech Sentiment Analyzer",
-        description="""
-        This tool performs advanced sentiment analysis on speech using RoBERTa.
-        It provides detailed sentiment analysis for longer texts and handles
-        both audio uploads and microphone recordings.
-        """,
-        theme=gr.themes.Soft(),
-        examples=[]
+        title="Speech Tone Analyzer",
+        description="Record or upload audio to analyze its emotional tone.",
+        theme=gr.themes.Soft()
     )
 
-def main():
-    """Launch the application"""
+if __name__ == "__main__":
     interface = create_interface()
     interface.launch(
         share=True,
-        debug=True,
         server_name="0.0.0.0"
-    )
-
-if __name__ == "__main__":
-    main()
+    )