Update app.py

app.py

@@ -21,45 +21,39 @@ import matplotlib.pyplot as plt
 from transformers import AutoModelForMaskedLM, AutoTokenizer
 import gradio as gr
 import re
+from collections import Counter
 
-print("Setting up custom emotion analysis model...")
+print("Setting up BERT-based emotion analysis model...")
 
-# Enhanced emotion categories with more keywords
+# Enhanced emotion categories with carefully selected keywords
 EMOTION_CATEGORIES = {
     'joy': [
-        'happy', 'joyful', 'delighted', 'pleased', 'excited', 'thrilled', 'cheerful', 
-        'content', 'glad', 'elated', 'ecstatic', 'jubilant', 'blissful', 'overjoyed',
-        'satisfied', 'euphoric', 'merry', 'radiant', 'gleeful', 'lighthearted'
+        'happy', 'joyful', 'delighted', 'excited', 'cheerful', 
+        'glad', 'elated', 'jubilant', 'overjoyed', 'pleased'
     ],
     'sadness': [
-        'sad', 'unhappy', 'depressed', 'gloomy', 'miserable', 'disappointed', 'sorrowful', 
-        'heartbroken', 'downcast', 'melancholy', 'despondent', 'disheartened', 'grief-stricken',
-        'somber', 'mournful', 'forlorn', 'dejected', 'crestfallen', 'woeful', 'desolate'
+        'sad', 'unhappy', 'depressed', 'disappointed', 'sorrowful', 
+        'heartbroken', 'melancholy', 'grief', 'somber', 'mournful'
     ],
     'anger': [
-        'angry', 'furious', 'enraged', 'irritated', 'annoyed', 'resentful', 'irate', 
-        'outraged', 'hostile', 'mad', 'incensed', 'livid', 'infuriated', 'seething',
-        'indignant', 'exasperated', 'bitter', 'vexed', 'aggravated', 'fuming'
+        'angry', 'furious', 'enraged', 'irritated', 'annoyed', 
+        'outraged', 'hostile', 'mad', 'infuriated', 'indignant'
     ],
     'fear': [
-        'afraid', 'scared', 'frightened', 'terrified', 'anxious', 'worried', 'nervous', 
-        'panicked', 'horrified', 'dreadful', 'apprehensive', 'petrified', 'paranoid',
-        'alarmed', 'uneasy', 'tense', 'distressed', 'intimidated', 'threatened', 'fearful'
+        'afraid', 'scared', 'frightened', 'terrified', 'anxious', 
+        'worried', 'nervous', 'panicked', 'horrified', 'apprehensive'
     ],
     'surprise': [
-        'surprised', 'amazed', 'astonished', 'shocked', 'stunned', 'startled', 'astounded', 
-        'bewildered', 'dumbfounded', 'unexpected', 'awestruck', 'flabbergasted', 'speechless',
-        'taken aback', 'thunderstruck', 'incredulous', 'staggered', 'perplexed', 'agape', 'overwhelmed'
+        'surprised', 'amazed', 'astonished', 'shocked', 'stunned', 
+        'startled', 'astounded', 'bewildered', 'unexpected', 'awestruck'
     ],
     'love': [
-        'loving', 'affectionate', 'fond', 'adoring', 'caring', 'devoted', 'passionate', 
-        'tender', 'warm', 'compassionate', 'enamored', 'cherishing', 'smitten',
-        'infatuated', 'admiring', 'doting', 'treasuring', 'nurturing', 'endearing', 'ardent'
+        'loving', 'affectionate', 'fond', 'adoring', 'caring', 
+        'devoted', 'passionate', 'tender', 'compassionate', 'cherishing'
     ],
     'sarcasm': [
-        'sarcastic', 'ironic', 'mocking', 'cynical', 'satirical', 'sardonic', 'facetious',
-        'contemptuous', 'sneering', 'scornful', 'caustic', 'biting', 'acerbic', 'cutting',
-        'derisive', 'dry', 'wry', 'tongue-in-cheek', 'insincere', 'patronizing'
+        'sarcastic', 'ironic', 'mocking', 'cynical', 'satirical', 
+        'sardonic', 'facetious', 'contemptuous', 'caustic', 'biting'
     ]
 }
 
@@ -74,6 +68,10 @@ EMOTION_COLORS = {
     'sarcasm': '#FF7F50'    # Coral
 }
 
+# Common positive and negative words for context analysis
+POSITIVE_WORDS = ['great', 'good', 'wonderful', 'amazing', 'excellent', 'fantastic', 'terrific', 'perfect', 'lovely', 'awesome']
+NEGATIVE_WORDS = ['bad', 'terrible', 'awful', 'horrible', 'poor', 'dreadful', 'disappointing', 'unpleasant', 'lousy', 'pathetic']
+
 # Load BERT model and tokenizer
 print("Loading BERT model and tokenizer (this may take a moment)...")
 model_name = "bert-base-uncased"
@@ -85,41 +83,124 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 model = model.to(device)
 print(f"Model loaded successfully. Using device: {device}")
 
-# Sarcasm indicators - linguistic patterns that might indicate sarcasm
+# Sarcasm indicators - carefully revised linguistic patterns that indicate sarcasm
 SARCASM_PATTERNS = [
-    r'\b(?:yeah|sure|right|wow|oh)(?:\s+right|\s+sure|\s+ok|\s+okay)?\s*$',  # Yeah right, Sure ok
-    r'\bso\s+(?:happy|excited|thrilled|glad|impressed)\b',  # So happy/excited (context dependent)
-    r'(?:^|\s)(?:thanks|thank you) for (?:nothing|that|pointing|stating)\b',  # Thanks for nothing
-    r'\b(?:just|exactly|precisely) what (?:I|we) need',  # Just what I need
-    r'\b(?:brilliant|genius|smart|clever|impressive)\b',  # Brilliant, genius (context dependent)
-    r'(?:\!|\?)\s*(?:\!|\?)+',  # Multiple exclamations/question marks
-    r'\bcongratulations\b',  # Congratulations (context dependent)
-    r'(?:^|\s)(?:oh|ah)\s+(?:really|wow|amazing|wonderful)\b',  # Oh really, Ah wonderful
+    # Exaggerated expressions with specific punctuation/capitalization patterns
+    r'(?i)\b(?:so+|really|absolutely|totally|completely)\s+(?:thrilled|excited|happy|delighted)\s+(?:about|with|by)\b.*?(?:\!{2,}|\?{2,})',
+    
+    # Classic sarcastic phrases
+    r'(?i)\bjust\s+what\s+(?:I|we)\s+(?:need|wanted|hoped for)\b',
+    r'(?i)\bhow\s+(?:wonderful|nice|great|lovely|exciting)\b.*?(?:\!|\?{2,})',
+    
+    # Contrasting statements
+    r'(?i)\b(?:love|enjoy|adore)\b.*?\bnot\b',
+    
+    # Quotation marks around positive words (scare quotes)
+    r'(?i)"(?:great|wonderful|excellent|perfect|amazing)"',
+    
+    # Typical sarcastic responses
+    r'(?i)^\s*(?:yeah|sure|right)\s+(?:ok|okay|whatever)\b',
+    
+    # Exaggerated praise in negative context
+    r'(?i)\b(?:brilliant|genius|impressive)\b.*?(?:terrible|awful|disaster|failure)',
+    
+    # Obvious understatements
+    r'(?i)\bslightly\s+(?:catastrophic|disastrous|terrible|awful)\b',
+    
+    # Emphasis on positive with hint of negative (requires context check)
+    r'(?i)\bso+\s+(?:happy|excited|thrilled|glad)'
 ]
 
-def detect_sarcasm_patterns(text):
-    """Detect linguistic patterns of sarcasm in text"""
-    # Convert to lowercase for case-insensitive matching
-    text_lower = text.lower()
+def tokenize_and_clean(text):
+    """Tokenize text and convert to lowercase"""
+    # Remove extra spaces and convert to lowercase
+    text = re.sub(r'\s+', ' ', text.lower().strip())
     
-    # Check for each sarcasm pattern
+    # Simple tokenization by splitting on spaces and removing punctuation
+    tokens = re.findall(r'\b\w+\b', text)
+    return tokens
+
+def count_sentiment_words(text):
+    """Count positive and negative words in text"""
+    tokens = tokenize_and_clean(text)
+    positive_count = sum(1 for word in tokens if word in POSITIVE_WORDS)
+    negative_count = sum(1 for word in tokens if word in NEGATIVE_WORDS)
+    return positive_count, negative_count
+
+def detect_sarcasm_patterns(text):
+    """Detect linguistic patterns of sarcasm in text with context awareness"""
+    # Match sarcasm patterns
     matches = 0
+    pattern_matches = []
+    
     for pattern in SARCASM_PATTERNS:
-        if re.search(pattern, text_lower):
+        if re.search(pattern, text):
             matches += 1
+            pattern_matches.append(pattern)
+    
+    # Check for sentiment polarity mismatch
+    positive_count, negative_count = count_sentiment_words(text)
     
-    # Calculate a basic sarcasm score based on matches
-    sarcasm_pattern_score = min(matches / 3, 1.0)  # Cap at 1.0
+    # Context-based signals
+    exclamation_count = text.count('!')
+    question_marks = text.count('?')
     
-    return sarcasm_pattern_score
+    # Check for positive words in negative contexts or vice versa
+    sentiment_mismatch = 0
+    if positive_count > 0 and negative_count > 0:
+        # If both positive and negative words exist, it's a potential indicator
+        sentiment_mismatch = min(positive_count, negative_count) / max(positive_count, negative_count, 1)
+    
+    # Check for excessive punctuation - potential sarcasm indicator
+    excessive_punctuation = 0
+    if exclamation_count > 2 or question_marks > 2:
+        excessive_punctuation = 0.2
+    
+    # Check for ALL CAPS words (excluding common acronyms)
+    caps_words = re.findall(r'\b[A-Z]{3,}\b', text)
+    caps_emphasis = len(caps_words) * 0.1  # Each caps word adds weight
+    
+    # Combined sarcasm score
+    raw_score = (matches * 0.15) + (sentiment_mismatch * 0.5) + excessive_punctuation + caps_emphasis
+    
+    # Normalize to [0, 1]
+    return min(raw_score, 1.0)
 
-def create_emotion_template(emotion_word):
-    """Create a template sentence for emotion prediction"""
-    return f"The text expresses [MASK] emotions. It feels {emotion_word}."
+def detect_extreme_incongruity(text):
+    """Detect extreme incongruity between sentiment and content"""
+    # Count positive and negative words
+    positive_count, negative_count = count_sentiment_words(text)
+    
+    # Check for specific incongruous phrases
+    incongruous_phrases = [
+        (r'(?i)\b(?:love|adore|enjoy)\b.*?\b(?:hate|despise|detest)\b', 0.7),  # "I love how much I hate this"
+        (r'(?i)\b(?:wonderful|great|excellent)\b.*?\b(?:terrible|awful|horrible)\b', 0.8),  # "What a wonderful disaster"
+        (r'(?i)\b(?:thankful|grateful)\b.*?\b(?:worst|annoying|frustrating)\b', 0.6),  # "So thankful for this frustrating experience"
+    ]
+    
+    incongruity_score = 0
+    for pattern, weight in incongruous_phrases:
+        if re.search(pattern, text):
+            incongruity_score += weight
+    
+    # Check for extreme emotional inconsistency
+    if positive_count > 2 and negative_count > 2:
+        # Significant presence of both positive and negative sentiment is suspicious
+        incongruity_score += 0.4
+    
+    return min(incongruity_score, 1.0)
 
-def create_sarcasm_template():
-    """Create a template sentence for sarcasm prediction"""
-    return "This text is [MASK] sarcastic."
+def create_emotion_template(emotion, keyword):
+    """Create a template sentence for emotion prediction"""
+    templates = [
+        f"The text expresses [MASK] {emotion} emotions.",
+        f"This text shows [MASK] {emotion} feelings.",
+        f"The writer feels [MASK] {keyword}.",
+        f"The sentiment in this text is [MASK] {keyword}."
+    ]
+    
+    # Use a consistent template for now, but this could be randomized
+    return templates[0]
 
 def predict_masked_token(text, template):
     """Get predictions for a masked token using BERT"""
@@ -146,140 +227,165 @@ def predict_masked_token(text, template):
     
     return probs
 
-def get_emotion_score(probs, positive_tokens, negative_tokens=None):
-    """Calculate emotion score based on token probabilities"""
-    # Get token IDs for positive and negative words
-    positive_ids = [tokenizer.convert_tokens_to_ids(word) for word in positive_tokens]
-    
-    # Calculate positive score (sum of probabilities of positive tokens)
-    positive_score = sum(probs[0, token_id].item() for token_id in positive_ids)
-    
-    # If negative tokens are provided, subtract their probabilities
-    negative_score = 0
-    if negative_tokens:
-        negative_ids = [tokenizer.convert_tokens_to_ids(word) for word in negative_tokens]
+def get_emotion_score(text, emotion, keywords):
+    """Calculate emotion score based on multiple template predictions"""
+    # Positive and negative indicator tokens
+    positive_indicators = ['clearly', 'definitely', 'strongly', 'very', 'extremely']
+    negative_indicators = ['not', 'barely', 'hardly', 'slightly', 'somewhat']
+    
+    # Get scores for each keyword using different templates
+    keyword_scores = []
+    
+    # Use a subset of keywords for efficiency
+    for keyword in keywords[:5]:  # Use just 5 keywords per emotion for efficiency
+        template = create_emotion_template(emotion, keyword)
+        probs = predict_masked_token(text, template)
+        
+        # Get token IDs for positive and negative words
+        positive_ids = [tokenizer.convert_tokens_to_ids(word) for word in positive_indicators]
+        negative_ids = [tokenizer.convert_tokens_to_ids(word) for word in negative_indicators]
+        
+        # Calculate positive score (sum of probabilities of positive tokens)
+        positive_score = sum(probs[0, token_id].item() for token_id in positive_ids)
         negative_score = sum(probs[0, token_id].item() for token_id in negative_ids)
+        
+        # Final score for this keyword
+        score = positive_score - negative_score
+        keyword_scores.append(score)
     
-    return positive_score - negative_score
+    # Return average score across all keywords
+    return sum(keyword_scores) / len(keyword_scores)
 
-def get_sarcasm_score(text, probs):
-    """Calculate sarcasm score based on token probabilities and linguistic patterns"""
+def analyze_sarcasm(text):
+    """Specialized analysis for sarcasm detection using multiple methods"""
+    # 1. Direct sarcasm template prediction
+    template = "This text is [MASK] sarcastic."
+    probs = predict_masked_token(text, template)
+    
     # Get token IDs for relevant words
-    positive_sarcasm_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                           ['definitely', 'very', 'extremely', 'clearly', 'obviously']]
-    negative_sarcasm_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                           ['not', 'barely', 'hardly', 'slightly', 'somewhat']]
+    positive_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
+                   ['definitely', 'very', 'extremely', 'clearly', 'obviously']]
+    negative_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
+                   ['not', 'barely', 'hardly', 'slightly', 'somewhat']]
     
-    # Calculate model-based score
-    positive_score = sum(probs[0, token_id].item() for token_id in positive_sarcasm_ids)
-    negative_score = sum(probs[0, token_id].item() for token_id in negative_sarcasm_ids)
-    model_score = positive_score - negative_score
+    bert_score = sum(probs[0, token_id].item() for token_id in positive_ids) - \
+                sum(probs[0, token_id].item() for token_id in negative_ids)
     
-    # Get pattern-based score
+    # 2. Linguistic pattern detection
     pattern_score = detect_sarcasm_patterns(text)
     
-    # Check for emotion contradiction (e.g., positive words with negative sentiment)
-    contradiction_score = 0
-    emotions_detected = {}
+    # 3. Sentiment incongruity detection
+    incongruity_score = detect_extreme_incongruity(text)
     
-    # Simple templates to check for emotional content
-    emotion_check_templates = {
-        'positive': "This text has a [MASK] tone.",  # Check for positive/negative/neutral
-        'intent': "The writer's intent is [MASK]."    # Check for serious/joking/sarcastic
-    }
+    # 4. Check intent
+    intent_template = "The writer's intent is [MASK]."
+    intent_probs = predict_masked_token(text, intent_template)
     
-    for template_name, template in emotion_check_templates.items():
-        check_probs = predict_masked_token(text, template)
-        
-        if template_name == 'positive':
-            # Check for contradiction between positive words and negative sentiment
-            positive_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                           ['positive', 'happy', 'good', 'great']]
-            negative_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                           ['negative', 'sad', 'bad', 'terrible']]
-            
-            positive_sentiment = sum(check_probs[0, token_id].item() for token_id in positive_ids)
-            negative_sentiment = sum(check_probs[0, token_id].item() for token_id in negative_ids)
-            
-            # High scores in both positive and negative can indicate sarcasm
-            contradiction_score += min(positive_sentiment, negative_sentiment) * 2
-        
-        elif template_name == 'intent':
-            # Check if model thinks the intent is sarcastic or joking
-            sarcastic_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                            ['sarcastic', 'ironic', 'joking', 'mocking']]
-            serious_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
-                          ['serious', 'sincere', 'honest', 'earnest']]
-            
-            sarcastic_intent = sum(check_probs[0, token_id].item() for token_id in sarcastic_ids)
-            serious_intent = sum(check_probs[0, token_id].item() for token_id in serious_ids)
-            
-            # If sarcastic intent is higher than serious intent, boost sarcasm score
-            if sarcastic_intent > serious_intent:
-                contradiction_score += (sarcastic_intent - serious_intent)
-    
-    # Combine scores - weight model-based prediction, pattern matching, and contradiction detection
-    combined_sarcasm_score = 0.4 * model_score + 0.3 * pattern_score + 0.3 * contradiction_score
-    
-    # Normalize to range [0,1]
-    return max(0, min(combined_sarcasm_score, 1))
+    sarcastic_intent_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
+                           ['sarcastic', 'ironic', 'mocking', 'joking']]
+    sincere_intent_ids = [tokenizer.convert_tokens_to_ids(word) for word in 
+                         ['sincere', 'serious', 'honest', 'genuine']]
+    
+    intent_score = sum(intent_probs[0, token_id].item() for token_id in sarcastic_intent_ids) - \
+                  sum(intent_probs[0, token_id].item() for token_id in sincere_intent_ids)
+    
+    # Weighted combination of all scores
+    combined_score = (0.3 * bert_score) + (0.3 * pattern_score) + \
+                    (0.2 * incongruity_score) + (0.2 * intent_score)
+    
+    # Normalize to [0, 1]
+    return max(0, min(combined_score, 1))
+
+def get_confidence_adjustment(text, emotion_scores):
+    """Adjust confidence based on text characteristics"""
+    # Text length adjustment - very short texts are harder to analyze
+    text_length = len(text.split())
+    length_factor = min(text_length / 20, 1.0)  # Texts with less than 20 words get reduced confidence
+    
+    # Emotion intensity - stronger emotions should have higher confidence
+    max_score = max(emotion_scores.values())
+    intensity_factor = max_score
+    
+    # Ambiguity adjustment - if multiple emotions have similar scores, reduce confidence
+    sorted_scores = sorted(emotion_scores.values(), reverse=True)
+    if len(sorted_scores) > 1:
+        top_gap = sorted_scores[0] - sorted_scores[1]
+        ambiguity_factor = min(top_gap * 2, 1.0)  # Small gap means ambiguous emotion
+    else:
+        ambiguity_factor = 1.0
+    
+    # Combined adjustment factor
+    adjustment = (length_factor + intensity_factor + ambiguity_factor) / 3
+    
+    return adjustment
 
 def analyze_emotions(text):
-    """Analyze emotions in text using custom BERT-based approach with sarcasm detection"""
+    """Analyze emotions in text using improved BERT-based approach with robust sarcasm detection"""
     if not text or not text.strip():
         return None, {"error": "Please enter some text to analyze"}
     
     try:
-        # Templates for emotion detection
+        # Calculate raw scores for each emotion
         emotion_scores = {}
         
-        # Positive emotion indicator tokens
-        positive_indicators = ['positive', 'strong', 'clear', 'definite', 'evident', 'genuine']
-        
-        # Negative indicators for contrasting emotions
-        negative_indicators = ['negative', 'weak', 'unclear', 'slight', 'fake', 'absent']
-        
-        # For each emotion category
+        # For each standard emotion category (excluding sarcasm)
         for emotion, keywords in EMOTION_CATEGORIES.items():
             if emotion == 'sarcasm':
-                # Special handling for sarcasm
-                template = create_sarcasm_template()
-                probs = predict_masked_token(text, template)
-                emotion_scores[emotion] = get_sarcasm_score(text, probs)
                 continue
                 
-            # Calculate score for each keyword and take average
-            keyword_scores = []
-            
-            # Use a subset of keywords to improve efficiency
-            selected_keywords = keywords[:10]  # Use first 10 keywords
-            
-            for keyword in selected_keywords:
-                template = create_emotion_template(keyword)
-                probs = predict_masked_token(text, template)
-                score = get_emotion_score(probs, positive_indicators, negative_indicators)
-                keyword_scores.append(score)
-            
-            # Take average score across all keywords for this emotion
-            emotion_scores[emotion] = sum(keyword_scores) / len(keyword_scores)
+            # Use specialized function to get emotion score
+            emotion_scores[emotion] = get_emotion_score(text, emotion, keywords)
+        
+        # Special handling for sarcasm with multi-method approach
+        emotion_scores['sarcasm'] = analyze_sarcasm(text)
+        
+        # Get confidence adjustment factor based on text characteristics
+        confidence_adjustment = get_confidence_adjustment(text, emotion_scores)
+        
+        # Apply chain-of-thought decision making for final analysis
+        final_scores = {}
         
-        # Normalize scores to ensure they sum to 1
-        min_score = min(emotion_scores.values())
-        max_score = max(emotion_scores.values())
-        score_range = max_score - min_score
+        # Step 1: Look for extremely high sarcasm score - this can override other emotions
+        if emotion_scores['sarcasm'] > 0.7:
+            # High sarcasm detected - reduce emotional scores
+            for emotion in emotion_scores:
+                if emotion != 'sarcasm':
+                    # Reduce other emotions based on sarcasm strength
+                    emotion_scores[emotion] *= (1 - (emotion_scores['sarcasm'] * 0.5))
         
-        if score_range > 0:
-            # Normal case - we have a range of scores
-            normalized_scores = {e: (s - min_score) / score_range for e, s in emotion_scores.items()}
-            # Further normalize to sum to 1
-            total = sum(normalized_scores.values())
-            normalized_scores = {e: s / total for e, s in normalized_scores.items()}
+        # Step 2: If sarcasm score is moderate (0.3-0.7), maintain other emotions but boost sarcasm
+        elif emotion_scores['sarcasm'] > 0.3:
+            # Moderate sarcasm - keep as complementary emotion
+            emotion_scores['sarcasm'] *= 1.2  # Slight boost to ensure it's noticed
+        
+        # Step 3: If sarcasm score is low, reduce it further
+        else:
+            emotion_scores['sarcasm'] *= 0.8  # Reduce low sarcasm scores to avoid false positives
+        
+        # Step 4: Check for emotional extremes that could override sarcasm
+        max_emotion = max(emotion_scores.items(), key=lambda x: x[1] if x[0] != 'sarcasm' else 0)
+        if max_emotion[1] > 0.7 and max_emotion[0] != 'sarcasm':
+            # Strong emotion detected - this could reduce sarcasm
+            emotion_scores['sarcasm'] *= 0.8
+        
+        # Step 5: Normalize scores to ensure they sum to 1
+        total_score = sum(emotion_scores.values())
+        if total_score > 0:
+            final_scores = {emotion: score / total_score for emotion, score in emotion_scores.items()}
         else:
-            # Edge case - all emotions scored the same
-            normalized_scores = {e: 1/len(emotion_scores) for e in emotion_scores}
+            # Fallback if all scores are zero
+            final_scores = {emotion: 1/len(emotion_scores) for emotion in emotion_scores}
+        
+        # Apply confidence adjustment
+        final_scores = {emotion: score * confidence_adjustment for emotion, score in final_scores.items()}
+        
+        # Normalize again after adjustment
+        total_adjusted = sum(final_scores.values())
+        if total_adjusted > 0:
+            final_scores = {emotion: score / total_adjusted for emotion, score in final_scores.items()}
         
         # Sort emotions by score
-        sorted_emotions = sorted(normalized_scores.items(), key=lambda x: x[1], reverse=True)
+        sorted_emotions = sorted(final_scores.items(), key=lambda x: x[1], reverse=True)
         emotions, scores = zip(*sorted_emotions)
         
         # Create visualization
@@ -292,9 +398,11 @@ def analyze_emotions(text):
             "detailed_scores": {emotion: f"{score*100:.1f}%" for emotion, score in zip(emotions, scores)}
         }
         
-        # Add sarcasm note if detected with high confidence
-        if 'sarcasm' in normalized_scores and normalized_scores['sarcasm'] > 0.2:
-            output["note"] = f"Sarcasm detected with {normalized_scores['sarcasm']*100:.1f}% confidence"
+        # Add contextual notes if applicable
+        if emotions[0] == 'sarcasm' and scores[0] > 0.3:
+            output["note"] = f"Sarcasm detected with {scores[0]*100:.1f}% confidence. Context suggests ironic or mocking tone."
+        elif 'sarcasm' in final_scores and final_scores['sarcasm'] > 0.2:
+            output["note"] = f"Some sarcastic elements detected alongside {emotions[0]}."
         
         return fig, output
         
@@ -328,7 +436,7 @@ def create_visualization(emotions, scores, text=None):
         display_text = text if len(text) < 50 else text[:47] + "..."
         ax.set_title(f'Emotion Analysis: "{display_text}"', pad=20)
     else:
-        ax.set_title('Custom Emotion Analysis', pad=20)
+        ax.set_title('BERT-based Emotion Analysis', pad=20)
     
     plt.tight_layout()
     return fig
@@ -345,10 +453,10 @@ demo = gr.Interface(
         gr.Plot(label="Emotion Distribution"),
         gr.JSON(label="Analysis Results")
     ],
-    title="🧠 Enhanced Emotion Analysis with Sarcasm Detection",
-    description="""This app analyzes emotions in text using a custom BERT-based approach. 
-    It examines how well the input text aligns with seven emotional categories: joy, sadness, anger, fear, surprise, love, and sarcasm.
-    The analysis uses BERT's contextual understanding along with linguistic pattern recognition to evaluate emotional content.""",
+    title="🧠 BERT-based Emotion Analysis",
+    description="""This app analyzes emotions in text using a specialized BERT-based approach. 
+    It identifies how well the input text aligns with seven emotional categories: joy, sadness, anger, fear, surprise, love, and sarcasm.
+    The analysis leverages BERT's contextual understanding along with sophisticated pattern recognition to evaluate emotional content.""",
     examples=[
         ["I can't wait for the concert tonight! It's going to be amazing!"],
         ["The news about the layoffs has left everyone feeling devastated."],