Update app.py

app.py

@@ -1,7 +1,8 @@
 import gradio as gr
 import torch
 import torchaudio
-from transformers import pipeline, AutoModel
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModel
+from torch.nn.functional import softmax
 import librosa
 import numpy as np
 import re
@@ -18,42 +19,28 @@ print("🚀 Starting Enhanced Hindi Speech Emotion Analysis App...")
 # 1. GLOBAL MODEL LOADING (ONLY ONCE AT STARTUP)
 # ============================================
 
-SENTIMENT_PIPELINE = None
-EMOTION_PIPELINE = None
+SENTIMENT_MODEL = None
+SENTIMENT_TOKENIZER = None
 ASR_MODEL = None
 
 def load_models():
     """Load all models once at startup and cache them globally"""
-    global SENTIMENT_PIPELINE, EMOTION_PIPELINE, ASR_MODEL
+    global SENTIMENT_MODEL, SENTIMENT_TOKENIZER, ASR_MODEL
     
-    if SENTIMENT_PIPELINE is not None and ASR_MODEL is not None and EMOTION_PIPELINE is not None:
+    if SENTIMENT_MODEL is not None and ASR_MODEL is not None:
         print("✅ Models already loaded, skipping...")
         return
     
-    print("📚 Loading Hindi sentiment analysis model...")
+    print("📚 Loading Hindi emotion analysis model...")
     try:
-        sentiment_model_name = "LondonStory/txlm-roberta-hindi-sentiment"
-        SENTIMENT_PIPELINE = pipeline(
-            "text-classification",
-            model=sentiment_model_name,
-            top_k=None
-        )
-        print("✅ Hindi sentiment model loaded successfully")
+        sentiment_model_name = "yashkahalkar/hindi_sentiment_analysis"
+        SENTIMENT_TOKENIZER = AutoTokenizer.from_pretrained(sentiment_model_name)
+        SENTIMENT_MODEL = AutoModelForSequenceClassification.from_pretrained(sentiment_model_name)
+        print("✅ Hindi emotion model loaded successfully")
     except Exception as e:
         print(f"❌ Error loading sentiment model: {e}")
         raise
     
-    print("🎭 Loading Zero-Shot Emotion Classification model...")
-    try:
-        EMOTION_PIPELINE = pipeline(
-            "zero-shot-classification",
-            model="joeddav/xlm-roberta-large-xnli"
-        )
-        print("✅ Zero-Shot emotion model loaded successfully")
-    except Exception as e:
-        print(f"❌ Error loading emotion model: {e}")
-        raise
-    
     print("🎤 Loading Indic Conformer 600M ASR model...")
     try:
         ASR_MODEL = AutoModel.from_pretrained(
@@ -70,45 +57,45 @@ def load_models():
 load_models()
 
 # ============================================
-# 2. EMOTION LABELS FOR ZERO-SHOT
+# 2. SENTIMENT PREDICTION FUNCTION
 # ============================================
 
-EMOTION_LABELS = [
-    "joy",
-    "happiness", 
-    "sadness",
-    "anger",
-    "fear",
-    "anxiety",
-    "love",
-    "surprise",
-    "disgust",
-    "calm",
-    "neutral",
-    "confusion",
-    "excitement",
-    "frustration",
-    "disappointment"
-]
-
-# Hindi translations for better multilingual understanding
-EMOTION_LABELS_HINDI = [
-    "खुशी",  # joy
-    "प्रसन्नता",  # happiness
-    "दुख",  # sadness
-    "गुस्सा",  # anger
-    "डर",  # fear
-    "चिंता",  # anxiety
-    "प्यार",  # love
-    "आश्चर्य",  # surprise
-    "घृणा",  # disgust
-    "शांति",  # calm
-    "सामान्य",  # neutral
-    "उलझन",  # confusion
-    "उत्साह",  # excitement
-    "निराशा",  # frustration
-    "मायूसी"  # disappointment
-]
+def predict_sentiment(text):
+    """
+    Predict sentiment/emotion using yashkahalkar/hindi_sentiment_analysis model
+    Detects: Happy, Sad, Angry, Neutral
+    Returns: dict with emotion label and scores
+    """
+    try:
+        inputs = SENTIMENT_TOKENIZER(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+        outputs = SENTIMENT_MODEL(**inputs)
+        probabilities = softmax(outputs.logits, dim=-1)
+        
+        # Get emotion index
+        emotion_idx = probabilities.argmax().item()
+        scores = probabilities[0].detach().numpy()
+        
+        # Label mapping for yashkahalkar model: Happy, Sad, Angry, Neutral
+        label_map = {0: 'sad', 1: 'angry', 2: 'happy', 3: 'neutral'}
+        emotion_label = label_map.get(emotion_idx, 'neutral')
+        
+        return {
+            'label': emotion_label,
+            'scores': {
+                'sad': float(scores[0]),
+                'angry': float(scores[1]),
+                'happy': float(scores[2]),
+                'neutral': float(scores[3]) if len(scores) > 3 else 0.0
+            },
+            'confidence': float(scores[emotion_idx])
+        }
+    except Exception as e:
+        print(f"⚠️ Sentiment prediction error: {e}")
+        return {
+            'label': 'neutral',
+            'scores': {'sad': 0.25, 'angry': 0.25, 'happy': 0.25, 'neutral': 0.25},
+            'confidence': 0.25
+        }
 
 # ============================================
 # 3. AUDIO PREPROCESSING FUNCTIONS
@@ -318,8 +305,8 @@ def detect_crisis_keywords(text):
             return True
     return False
 
-def detect_mixed_emotions(text, prosodic_features):
-    """Detect mixed emotions"""
+def detect_mixed_sentiment(text):
+    """Detect if text contains mixed or conflicting sentiment indicators"""
     text_lower = text.lower()
     
     if detect_crisis_keywords(text):
@@ -352,133 +339,59 @@ async def async_sentiment_analysis(text):
     """Run sentiment analysis asynchronously"""
     loop = asyncio.get_event_loop()
     with ThreadPoolExecutor() as executor:
-        result = await loop.run_in_executor(executor, SENTIMENT_PIPELINE, text)
+        result = await loop.run_in_executor(executor, predict_sentiment, text)
     return result
 
-async def async_emotion_classification(text):
-    """Run zero-shot emotion classification asynchronously"""
-    loop = asyncio.get_event_loop()
-    with ThreadPoolExecutor() as executor:
-        # Use both English and Hindi labels for better multilingual performance
-        all_labels = EMOTION_LABELS + EMOTION_LABELS_HINDI
-        result = await loop.run_in_executor(
-            executor, 
-            lambda: EMOTION_PIPELINE(text, all_labels, multi_label=False)
-        )
-    return result
-
-async def parallel_analysis(text):
-    """Run sentiment and emotion analysis in parallel"""
-    print("🔄 Running parallel sentiment and emotion analysis...")
-    
-    # Execute both analyses concurrently
-    sentiment_task = async_sentiment_analysis(text)
-    emotion_task = async_emotion_classification(text)
-    
-    sentiment_result, emotion_result = await asyncio.gather(
-        sentiment_task, 
-        emotion_task,
-        return_exceptions=True
-    )
-    
-    return sentiment_result, emotion_result
-
 # ============================================
 # 7. ENHANCED SENTIMENT ANALYSIS
 # ============================================
 
 def enhanced_sentiment_analysis(text, prosodic_features, raw_results):
-    """Enhanced sentiment analysis"""
-    sentiment_scores = {}
-    
-    if not raw_results or not isinstance(raw_results, list) or len(raw_results) == 0:
-        return {'Negative': 0.33, 'Neutral': 0.34, 'Positive': 0.33}, 0.34, False
-    
-    label_mapping = {
-        'LABEL_0': 'Negative',
-        'LABEL_1': 'Neutral',
-        'LABEL_2': 'Positive',
-        'negative': 'Negative',
-        'neutral': 'Neutral',
-        'positive': 'Positive'
+    """Enhanced emotion analysis with context awareness"""
+    if not raw_results or not isinstance(raw_results, dict):
+        return {'sad': 0.25, 'angry': 0.25, 'happy': 0.25, 'neutral': 0.25}, 0.25, False
+    
+    # Get base scores from model
+    emotion_scores = {
+        'sad': raw_results['scores']['sad'],
+        'angry': raw_results['scores']['angry'],
+        'happy': raw_results['scores']['happy'],
+        'neutral': raw_results['scores']['neutral']
     }
     
-    for result in raw_results[0]:
-        label = result['label']
-        score = result['score']
-        mapped_label = label_mapping.get(label, 'Neutral')
-        sentiment_scores[mapped_label] = score
-    
-    for sentiment in ['Negative', 'Neutral', 'Positive']:
-        if sentiment not in sentiment_scores:
-            sentiment_scores[sentiment] = 0.0
-    
     is_crisis = detect_crisis_keywords(text)
     if is_crisis:
-        sentiment_scores['Negative'] = min(0.95, sentiment_scores['Negative'] * 1.8)
-        sentiment_scores['Neutral'] = max(0.02, sentiment_scores['Neutral'] * 0.2)
-        sentiment_scores['Positive'] = max(0.01, sentiment_scores['Positive'] * 0.1)
+        # Boost negative emotions for crisis situations
+        emotion_scores['sad'] = min(0.50, emotion_scores['sad'] * 1.5)
+        emotion_scores['angry'] = min(0.50, emotion_scores['angry'] * 1.5)
+        emotion_scores['neutral'] = max(0.02, emotion_scores['neutral'] * 0.2)
+        emotion_scores['happy'] = max(0.01, emotion_scores['happy'] * 0.1)
         is_mixed = False
     else:
         has_negation = detect_negation(text)
         if has_negation:
-            temp = sentiment_scores['Positive']
-            sentiment_scores['Positive'] = sentiment_scores['Negative']
-            sentiment_scores['Negative'] = temp
+            # Swap happy with sad on negation
+            temp = emotion_scores['happy']
+            emotion_scores['happy'] = emotion_scores['sad']
+            emotion_scores['sad'] = temp
         
-        is_mixed = detect_mixed_emotions(text, prosodic_features)
+        is_mixed = detect_mixed_sentiment(text)
         if is_mixed:
+            # Boost neutral for mixed emotions
             neutral_boost = 0.20
-            sentiment_scores['Neutral'] = min(0.65, sentiment_scores['Neutral'] + neutral_boost)
-            sentiment_scores['Positive'] = max(0.1, sentiment_scores['Positive'] - neutral_boost/2)
-            sentiment_scores['Negative'] = max(0.1, sentiment_scores['Negative'] - neutral_boost/2)
+            emotion_scores['neutral'] = min(0.65, emotion_scores['neutral'] + neutral_boost)
+            emotion_scores['happy'] = max(0.05, emotion_scores['happy'] - neutral_boost/3)
+            emotion_scores['sad'] = max(0.05, emotion_scores['sad'] - neutral_boost/3)
+            emotion_scores['angry'] = max(0.05, emotion_scores['angry'] - neutral_boost/3)
     
-    total = sum(sentiment_scores.values())
+    # Normalize scores
+    total = sum(emotion_scores.values())
     if total > 0:
-        sentiment_scores = {k: v/total for k, v in sentiment_scores.items()}
+        emotion_scores = {k: v/total for k, v in emotion_scores.items()}
     
-    final_confidence = max(sentiment_scores.values())
-    
-    return sentiment_scores, final_confidence, is_mixed
-
-def process_emotion_results(emotion_result):
-    """Process zero-shot emotion classification results"""
-    if isinstance(emotion_result, Exception):
-        print(f"⚠️ Emotion classification error: {emotion_result}")
-        return {
-            "primary": "unknown",
-            "secondary": None,
-            "confidence": 0.0,
-            "top_emotions": []
-        }
+    final_confidence = max(emotion_scores.values())
     
-    # Get top 5 emotions
-    labels = emotion_result['labels']
-    scores = emotion_result['scores']
-    
-    # Map Hindi labels back to English
-    hindi_to_english = dict(zip(EMOTION_LABELS_HINDI, EMOTION_LABELS))
-    
-    top_emotions = []
-    for i in range(min(5, len(labels))):
-        label = labels[i]
-        # Convert Hindi to English if necessary
-        english_label = hindi_to_english.get(label, label)
-        top_emotions.append({
-            "emotion": english_label,
-            "score": round(scores[i], 4)
-        })
-    
-    primary_emotion = top_emotions[0]["emotion"] if top_emotions else "unknown"
-    secondary_emotion = top_emotions[1]["emotion"] if len(top_emotions) > 1 else None
-    confidence = top_emotions[0]["score"] if top_emotions else 0.0
-    
-    return {
-        "primary": primary_emotion,
-        "secondary": secondary_emotion,
-        "confidence": round(confidence, 4),
-        "top_emotions": top_emotions
-    }
+    return emotion_scores, final_confidence, is_mixed
 
 # ============================================
 # 8. MAIN PREDICTION FUNCTION
@@ -549,37 +462,35 @@ def predict(audio_filepath):
                 "hindi_content_percentage": round(hindi_ratio * 100, 2)
             }
         
-        # Parallel Sentiment and Emotion Analysis
-        print("💭 Analyzing sentiment and emotions in parallel...")
+        # Emotion Analysis
+        print("💭 Analyzing emotion...")
         try:
-            # Run both analyses concurrently
-            sentiment_result, emotion_result = asyncio.run(parallel_analysis(transcription))
+            # Run emotion analysis
+            emotion_result = asyncio.run(async_sentiment_analysis(transcription))
             
-            # Process sentiment
-            sentiment_scores, confidence, is_mixed = enhanced_sentiment_analysis(
+            # Process emotion with context enhancement
+            emotion_scores, confidence, is_mixed = enhanced_sentiment_analysis(
                 transcription, 
                 prosodic_features, 
-                sentiment_result
+                emotion_result
             )
             
-            # Process emotion
-            emotion_data = process_emotion_results(emotion_result)
+            dominant_emotion = max(emotion_scores, key=emotion_scores.get)
             
-            print(f"✅ Detected Emotion: {emotion_data['primary']}")
-            print(f"✅ Sentiment: {max(sentiment_scores, key=sentiment_scores.get)}")
+            print(f"✅ Emotion: {dominant_emotion}")
             print(f"📝 Transcription: {transcription}")
             
             # Build structured output
             result = {
                 "status": "success",
                 "transcription": transcription,
-                "emotion": emotion_data,
-                "sentiment": {
-                    "dominant": max(sentiment_scores, key=sentiment_scores.get),
+                "emotion": {
+                    "dominant": dominant_emotion,
                     "scores": {
-                        "positive": round(sentiment_scores['Positive'], 4),
-                        "neutral": round(sentiment_scores['Neutral'], 4),
-                        "negative": round(sentiment_scores['Negative'], 4)
+                        "happy": round(emotion_scores['happy'], 4),
+                        "sad": round(emotion_scores['sad'], 4),
+                        "angry": round(emotion_scores['angry'], 4),
+                        "neutral": round(emotion_scores['neutral'], 4)
                     },
                     "confidence": round(confidence, 4)
                 },
@@ -632,16 +543,15 @@ demo = gr.Interface(
         label="🎤 Record or Upload Hindi Audio",
         sources=["upload", "microphone"]
     ),
-    outputs=gr.JSON(label="📊 Emotion & Sentiment Analysis Results (API-Ready JSON)"),
-    title="🎭 Hindi Speech Emotion & Sentiment Analysis API",
+    outputs=gr.JSON(label="📊 Emotion Analysis Results (API-Ready JSON)"),
+    title="🎭 Hindi Speech Emotion Analysis API",
     description="""
-    ## 🇮🇳 Advanced Hindi/Hinglish Speech Emotion & Sentiment Detection
+    ## 🇮🇳 Advanced Hindi/Hinglish Speech Emotion Detection
     
     ### ✨ Features:
     - **🎙️ Indic Conformer 600M** - State-of-the-art multilingual ASR
-    - **🎭 Zero-Shot Emotion Detection** - 15+ emotions using joeddav/xlm-roberta-large-xnli
-    - **💭 Sentiment Analysis** - Positive/Neutral/Negative classification
-    - **⚡ Parallel Processing** - Async execution for faster results
+    - **🎭 Emotion Classification** - Using yashkahalkar/hindi_sentiment_analysis
+    - **⚡ Async Processing** - Fast emotion detection
     - **🎵 Voice Analysis** - Analyzes tone, pitch, energy, and spectral features
     - **🌐 Hinglish Support** - Works with Hindi + English mix
     - **📝 JSON Output** - Easy to parse for API integration
@@ -650,23 +560,14 @@ demo = gr.Interface(
     ```json
     {
       "status": "success",
-      "transcription": "मैं बहुत खुश हूं",
+      "transcription": "मुझे आज बहुत खुशी हो रही है",
       "emotion": {
-        "primary": "joy",
-        "secondary": "happiness",
-        "confidence": 0.8745,
-        "top_emotions": [
-          {"emotion": "joy", "score": 0.8745},
-          {"emotion": "happiness", "score": 0.0923},
-          {"emotion": "excitement", "score": 0.0332}
-        ]
-      },
-      "sentiment": {
-        "dominant": "Positive",
+        "dominant": "happy",
         "scores": {
-          "positive": 0.8745,
-          "neutral": 0.0923,
-          "negative": 0.0332
+          "happy": 0.8745,
+          "sad": 0.0432,
+          "angry": 0.0321,
+          "neutral": 0.0502
         },
         "confidence": 0.8745
       },
@@ -686,18 +587,17 @@ demo = gr.Interface(
     }
     ```
     
-    ### 🎯 Supported Emotions (15+):
-    - **Positive**: joy, happiness, love, excitement, calm
-    - **Negative**: sadness, anger, fear, anxiety, disgust, frustration, disappointment
-    - **Neutral**: neutral, confusion, surprise
+    ### 🎯 Emotion Classes:
+    - **😃 Happy**: Joyful, cheerful, optimistic content
+    - **😞 Sad**: Sorrowful, disappointed, melancholic content
+    - **😠 Angry**: Frustrated, irritated, aggressive content
+    - **😐 Neutral**: Factual, balanced, or informational content
     
     ### 🧪 Test Examples:
-    - **😊 Joy**: "मैं बहुत खुश हूं आज"
-    - **😢 Sadness**: "मुझे बहुत दुख हो रहा है"
-    - **😠 Anger**: "मुझे बहुत गुस्सा आ रहा है"
-    - **😨 Fear**: "मुझे डर लग रहा है"
-    - **😐 Calm**: "सब ठीक है, मैं शांत हूं"
-    - **❤️ Love**: "मुझे तुमसे बहुत प्यार है"
+    - **😃 Happy**: "मुझे आज बहुत खुशी हो रही है"
+    - **😞 Sad**: "मुझे बहुत दुख हो रहा है"
+    - **😠 Angry**: "मुझे बहुत गुस्सा आ रहा है"
+    - **😐 Neutral**: "आज मौसम अच्छा है"
     
     ### 💡 API Usage:
     
@@ -714,15 +614,16 @@ demo = gr.Interface(
     result = response.json()
     
     if result["status"] == "success":
-        print(f"Emotion: {result['emotion']['primary']}")
-        print(f"Sentiment: {result['sentiment']['dominant']}")
-        print(f"Top 3 emotions: {result['emotion']['top_emotions'][:3]}")
+        print(f"Transcription: {result['transcription']}")
+        print(f"Emotion: {result['emotion']['dominant']}")
+        print(f"Confidence: {result['emotion']['confidence']}")
+        print(f"All emotions: {result['emotion']['scores']}")
     ```
     
     **Async Processing Benefits:**
-    - ⚡ 2x faster analysis (parallel execution)
+    - ⚡ Fast emotion analysis
     - 🔄 Non-blocking I/O operations
-    - 💪 Better resource utilization
+    - 💪 Efficient resource utilization
     """,
     theme=gr.themes.Soft(),
     flagging_mode="never",
@@ -738,4 +639,4 @@ demo = gr.Interface(
 if __name__ == "__main__":
     print("🌐 Starting server...")
     demo.launch()
-    print("🎉 Hindi Emotion & Sentiment Analysis API is ready!")
+    print("🎉 Hindi Emotion Analysis API is ready!")