Update app.py

app.py

@@ -68,9 +68,53 @@ 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']
+# Common sentiment phrases and expressions for improved detection
+EMOTION_PHRASES = {
+    'joy': [
+        'over the moon', 'on cloud nine', 'couldn\'t be happier', 
+        'best day ever', 'made my day', 'feeling great',
+        'absolutely thrilled', 'jumping for joy'
+    ],
+    'sadness': [
+        'broke my heart', 'in tears', 'feel like crying', 
+        'deeply saddened', 'lost all hope', 'feel empty',
+        'devastating news', 'hit hard', 'feel down'
+    ],
+    'anger': [
+        'makes my blood boil', 'fed up with', 'had it with', 
+        'sick and tired of', 'drives me crazy', 'lost my temper',
+        'absolutely furious', 'beyond frustrated'
+    ],
+    'fear': [
+        'scared to death', 'freaking out', 'keeps me up at night', 
+        'terrified of', 'living in fear', 'panic attack',
+        'nervous wreck', 'can\'t stop worrying'
+    ],
+    'surprise': [
+        'can\'t believe', 'took me by surprise', 'out of nowhere', 
+        'never expected', 'caught off guard', 'mind blown',
+        'plot twist', 'jaw dropped'
+    ],
+    'love': [
+        'deeply in love', 'means the world to me', 'treasure every moment', 
+        'hold dear', 'close to my heart', 'forever grateful',
+        'truly blessed', 'never felt this way'
+    ],
+    'sarcasm': [
+        'just what I needed', 'couldn\'t get any better', 'how wonderful', 
+        'oh great', 'lucky me', 'my favorite part',
+        'thrilled to bits', 'way to go', 'thanks for nothing'
+    ]
+}
+
+# Contextual emotion indicators for better analysis
+CONTEXTUAL_INDICATORS = {
+    'intensifiers': ['very', 'extremely', 'incredibly', 'absolutely', 'totally', 'completely', 'utterly'],
+    'negators': ['not', 'never', 'no', 'none', 'neither', 'nor', 'hardly', 'barely'],
+    'hedges': ['somewhat', 'kind of', 'sort of', 'a bit', 'slightly', 'perhaps', 'maybe'],
+    'boosters': ['definitely', 'certainly', 'absolutely', 'undoubtedly', 'surely', 'clearly'],
+    'punctuation': {'!': 'emphasis', '?': 'question', '...': 'hesitation'}
+}
 
 # Load BERT model and tokenizer
 print("Loading BERT model and tokenizer (this may take a moment)...")
@@ -83,32 +127,32 @@ 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 - carefully revised linguistic patterns that indicate sarcasm
+# Sarcasm patterns with refined detection logic
 SARCASM_PATTERNS = [
-    # 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,})',
+    # Exaggerated positive with negative context
+    r'(?i)\b(?:so+|really|absolutely|totally|completely)\s+(?:thrilled|excited|happy|delighted)\s+(?:about|with|by)\b.*?(?:terrible|awful|worst|bad)',
     
     # 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,})',
+    r'(?i)(?:^|\W)just\s+what\s+(?:I|we)\s+(?:need|wanted|hoped for)\b',
+    r'(?i)(?:^|\W)how\s+(?:wonderful|nice|great|lovely|exciting)\b.*?(?:\!|\?{2,})',
     
-    # Contrasting statements
-    r'(?i)\b(?:love|enjoy|adore)\b.*?\bnot\b',
+    # Thanks for nothing pattern
+    r'(?i)(?:^|\W)thanks\s+for\s+(?:nothing|that|pointing|stating)\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',
+    r'(?i)^(?:yeah|sure|right|oh)\s+(?:right|sure|okay|ok)(?:\W|$)',
     
     # Exaggerated praise in negative context
-    r'(?i)\b(?:brilliant|genius|impressive)\b.*?(?:terrible|awful|disaster|failure)',
+    r'(?i)\b(?:brilliant|genius|impressive)\b.*?(?:disaster|failure|mess)',
     
     # Obvious understatements
-    r'(?i)\bslightly\s+(?:catastrophic|disastrous|terrible|awful)\b',
+    r'(?i)\b(?:slightly|bit|little)\s+(?:catastrophic|disastrous|terrible|awful)\b',
     
-    # Emphasis on positive with hint of negative (requires context check)
-    r'(?i)\bso+\s+(?:happy|excited|thrilled|glad)'
+    # Oh great patterns
+    r'(?i)(?:^|\W)oh\s+(?:great|wonderful|perfect|fantastic|awesome)(?:\W|$)'
 ]
 
 def tokenize_and_clean(text):
@@ -120,12 +164,49 @@ def tokenize_and_clean(text):
     tokens = re.findall(r'\b\w+\b', text)
     return tokens
 
-def count_sentiment_words(text):
-    """Count positive and negative words in text"""
+def detect_phrases(text, emotion_phrases):
+    """Detect emotion-specific phrases in text"""
+    text_lower = text.lower()
+    detected_phrases = {}
+    
+    for emotion, phrases in emotion_phrases.items():
+        found_phrases = []
+        for phrase in phrases:
+            if phrase.lower() in text_lower:
+                found_phrases.append(phrase)
+        
+        if found_phrases:
+            detected_phrases[emotion] = found_phrases
+    
+    return detected_phrases
+
+def detect_contextual_features(text):
+    """Detect contextual features in text that may influence emotion"""
+    features = {
+        'intensifiers': 0,
+        'negators': 0,
+        'hedges': 0,
+        'boosters': 0,
+        'exclamations': text.count('!'),
+        'questions': text.count('?'),
+        'ellipses': text.count('...'),
+        'capitalized_words': len(re.findall(r'\b[A-Z]{2,}\b', text))
+    }
+    
+    text_lower = text.lower()
     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
+    
+    # Count contextual indicators
+    for indicator_type, words in CONTEXTUAL_INDICATORS.items():
+        if indicator_type != 'punctuation':
+            for word in words:
+                if ' ' in word:  # Multi-word phrase
+                    if word in text_lower:
+                        features[indicator_type] += 1
+                else:  # Single word
+                    features[indicator_type] += tokens.count(word)
+    
+    return features
 
 def detect_sarcasm_patterns(text):
     """Detect linguistic patterns of sarcasm in text with context awareness"""
@@ -138,68 +219,80 @@ def detect_sarcasm_patterns(text):
             matches += 1
             pattern_matches.append(pattern)
     
-    # Check for sentiment polarity mismatch
-    positive_count, negative_count = count_sentiment_words(text)
+    # Get contextual features
+    features = detect_contextual_features(text)
+    
+    # Check for phrases specific to sarcasm
+    phrases = detect_phrases(text, {'sarcasm': EMOTION_PHRASES['sarcasm']})
+    sarcasm_phrases = len(phrases.get('sarcasm', []))
     
-    # Context-based signals
-    exclamation_count = text.count('!')
-    question_marks = text.count('?')
+    # Calculate raw score based on pattern matches and features
+    raw_score = (matches * 0.15) + (sarcasm_phrases * 0.2)
     
-    # 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)
+    # Adjust based on contextual features
+    if features['exclamations'] > 1:
+        raw_score += min(features['exclamations'] * 0.05, 0.2)
     
-    # Check for excessive punctuation - potential sarcasm indicator
-    excessive_punctuation = 0
-    if exclamation_count > 2 or question_marks > 2:
-        excessive_punctuation = 0.2
+    if features['capitalized_words'] > 0:
+        raw_score += min(features['capitalized_words'] * 0.1, 0.3)
     
-    # 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
+    # Detect positive-negative contrasts
+    pos_neg_contrast = 0
+    emotion_phrases = detect_phrases(text, {
+        'positive': EMOTION_PHRASES['joy'] + EMOTION_PHRASES['love'],
+        'negative': EMOTION_PHRASES['sadness'] + EMOTION_PHRASES['anger']
+    })
     
-    # Combined sarcasm score
-    raw_score = (matches * 0.15) + (sentiment_mismatch * 0.5) + excessive_punctuation + caps_emphasis
+    if emotion_phrases.get('positive') and emotion_phrases.get('negative'):
+        pos_neg_contrast = 0.3
+    
+    # Add contrast score
+    raw_score += pos_neg_contrast
     
     # Normalize to [0, 1]
-    return min(raw_score, 1.0)
+    return min(raw_score, 1.0), pattern_matches
 
-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"
-    ]
+def get_bert_sentence_embedding(text):
+    """Get BERT embedding for a sentence"""
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
     
-    incongruity_score = 0
-    for pattern, weight in incongruous_phrases:
-        if re.search(pattern, text):
-            incongruity_score += weight
+    with torch.no_grad():
+        outputs = model(**inputs, output_hidden_states=True)
+    
+    # Get the last hidden state
+    last_hidden_state = outputs.hidden_states[-1]
+    
+    # Mean pooling - take average of all token embeddings
+    sentence_embedding = torch.mean(last_hidden_state[0], dim=0)
     
-    # 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 sentence_embedding
+
+def semantic_similarity(text1, text2):
+    """Calculate semantic similarity between two texts using BERT embeddings"""
+    # Get embeddings
+    emb1 = get_bert_sentence_embedding(text1)
+    emb2 = get_bert_sentence_embedding(text2)
+    
+    # Normalize embeddings
+    emb1 = emb1 / emb1.norm()
+    emb2 = emb2 / emb2.norm()
     
-    return min(incongruity_score, 1.0)
+    # Calculate cosine similarity
+    similarity = torch.dot(emb1, emb2).item()
+    
+    return similarity
 
-def create_emotion_template(emotion, keyword):
+def create_emotional_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"This text shows [MASK] {keyword} 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
+    # Use a consistent template for now
     return templates[0]
 
 def predict_masked_token(text, template):
@@ -228,7 +321,7 @@ def predict_masked_token(text, template):
     return probs
 
 def get_emotion_score(text, emotion, keywords):
-    """Calculate emotion score based on multiple template predictions"""
+    """Calculate emotion score based on multiple template predictions and phrase detection"""
     # Positive and negative indicator tokens
     positive_indicators = ['clearly', 'definitely', 'strongly', 'very', 'extremely']
     negative_indicators = ['not', 'barely', 'hardly', 'slightly', 'somewhat']
@@ -238,7 +331,7 @@ def get_emotion_score(text, emotion, keywords):
     
     # 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)
+        template = create_emotional_template(emotion, keyword)
         probs = predict_masked_token(text, template)
         
         # Get token IDs for positive and negative words
@@ -253,8 +346,35 @@ def get_emotion_score(text, emotion, keywords):
         score = positive_score - negative_score
         keyword_scores.append(score)
     
-    # Return average score across all keywords
-    return sum(keyword_scores) / len(keyword_scores)
+    # Check for emotion-specific phrases
+    detected_phrases = detect_phrases(text, {emotion: EMOTION_PHRASES[emotion]})
+    phrase_count = len(detected_phrases.get(emotion, []))
+    phrase_score = min(phrase_count * 0.2, 0.6)  # Cap at 0.6
+    
+    # Get contextual features
+    features = detect_contextual_features(text)
+    
+    # Calculate feature-based adjustment
+    feature_adjustment = 0
+    
+    # Adjust score based on emotional context
+    if emotion in ['joy', 'love', 'surprise'] and features['exclamations'] > 0:
+        feature_adjustment += min(features['exclamations'] * 0.05, 0.2)
+    
+    if emotion in ['anger', 'sadness'] and features['negators'] > 0:
+        feature_adjustment += min(features['negators'] * 0.05, 0.2)
+    
+    if emotion == 'fear' and features['intensifiers'] > 0:
+        feature_adjustment += min(features['intensifiers'] * 0.05, 0.2)
+    
+    # Average BERT-based score
+    bert_score = sum(keyword_scores) / len(keyword_scores)
+    
+    # Combine BERT score with phrase detection and context adjustments
+    final_score = (bert_score * 0.6) + (phrase_score * 0.3) + (feature_adjustment * 0.1)
+    
+    # Normalize to ensure it's in [0, 1]
+    return max(0, min(final_score, 1.0)), detected_phrases.get(emotion, [])
 
 def analyze_sarcasm(text):
     """Specialized analysis for sarcasm detection using multiple methods"""
@@ -272,10 +392,23 @@ def analyze_sarcasm(text):
                 sum(probs[0, token_id].item() for token_id in negative_ids)
     
     # 2. Linguistic pattern detection
-    pattern_score = detect_sarcasm_patterns(text)
+    pattern_score, pattern_matches = detect_sarcasm_patterns(text)
     
-    # 3. Sentiment incongruity detection
-    incongruity_score = detect_extreme_incongruity(text)
+    # 3. Check for semantic incongruity using BERT
+    incongruity_score = 0
+    
+    # Split text into sentences
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    if len(sentences) > 1:
+        # Check semantic similarity between adjacent sentences
+        similarities = []
+        for i in range(len(sentences) - 1):
+            sim = semantic_similarity(sentences[i], sentences[i+1])
+            similarities.append(sim)
+        
+        # Low similarity between adjacent sentences might indicate sarcasm
+        if similarities and min(similarities) < 0.5:
+            incongruity_score = 0.3
     
     # 4. Check intent
     intent_template = "The writer's intent is [MASK]."
@@ -289,119 +422,126 @@ def analyze_sarcasm(text):
     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)
     
+    # 5. Check for sarcasm phrases
+    detected_phrases = detect_phrases(text, {'sarcasm': EMOTION_PHRASES['sarcasm']})
+    phrase_score = min(len(detected_phrases.get('sarcasm', [])) * 0.2, 0.6)
+    
     # Weighted combination of all scores
-    combined_score = (0.3 * bert_score) + (0.3 * pattern_score) + \
-                    (0.2 * incongruity_score) + (0.2 * intent_score)
+    combined_score = (0.2 * bert_score) + (0.25 * pattern_score) + \
+                    (0.15 * incongruity_score) + (0.15 * intent_score) + \
+                    (0.25 * phrase_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
+    return max(0, min(combined_score, 1.0)), detected_phrases.get('sarcasm', []), pattern_matches
 
 def analyze_emotions(text):
-    """Analyze emotions in text using improved BERT-based approach with robust sarcasm detection"""
+    """Analyze emotions in text using enhanced BERT-based approach with robust sarcasm detection"""
     if not text or not text.strip():
         return None, {"error": "Please enter some text to analyze"}
     
     try:
-        # Calculate raw scores for each emotion
-        emotion_scores = {}
+        # Calculate scores for each emotion with supporting phrases
+        emotion_data = {}
         
         # For each standard emotion category (excluding sarcasm)
         for emotion, keywords in EMOTION_CATEGORIES.items():
             if emotion == 'sarcasm':
                 continue
                 
-            # Use specialized function to get emotion score
-            emotion_scores[emotion] = get_emotion_score(text, emotion, keywords)
+            # Use specialized function to get emotion score and supporting phrases
+            score, phrases = get_emotion_score(text, emotion, keywords)
+            emotion_data[emotion] = {
+                'score': score,
+                'phrases': phrases
+            }
         
         # Special handling for sarcasm with multi-method approach
-        emotion_scores['sarcasm'] = analyze_sarcasm(text)
+        sarcasm_score, sarcasm_phrases, sarcasm_patterns = analyze_sarcasm(text)
+        emotion_data['sarcasm'] = {
+            'score': sarcasm_score,
+            'phrases': sarcasm_phrases,
+            'patterns': sarcasm_patterns
+        }
         
-        # Get confidence adjustment factor based on text characteristics
-        confidence_adjustment = get_confidence_adjustment(text, emotion_scores)
+        # Get contextual features for overall analysis
+        context_features = detect_contextual_features(text)
         
         # Apply chain-of-thought decision making for final analysis
-        final_scores = {}
+        # 1. Check for dominant emotions by raw scores
+        emotion_scores = {emotion: data['score'] for emotion, data in emotion_data.items()}
         
-        # 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
+        # 2. Adjust based on contextual evidence
+        # If we have strong phrase evidence, boost those emotions
+        for emotion, data in emotion_data.items():
+            if len(data.get('phrases', [])) >= 2:
+                emotion_scores[emotion] = emotion_scores[emotion] * 1.2
+                
+        # 3. Adjust sarcasm based on specific rules
+        if emotion_scores['sarcasm'] > 0.6:
+            # High sarcasm - reduce intensity of other emotions
             for emotion in emotion_scores:
                 if emotion != 'sarcasm':
-                    # Reduce other emotions based on sarcasm strength
-                    emotion_scores[emotion] *= (1 - (emotion_scores['sarcasm'] * 0.5))
-        
-        # Step 2: If sarcasm score is moderate (0.3-0.7), maintain other emotions but boost sarcasm
+                    emotion_scores[emotion] *= 0.8
         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
+            pass
         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
+            # Low sarcasm - reduce it further to avoid false positives
+            emotion_scores['sarcasm'] *= 0.7
+            
+        # 4. Check for unusually high emotions that might override sarcasm
+        non_sarcasm_emotions = {e: s for e, s in emotion_scores.items() if e != 'sarcasm'}
+        max_emotion = max(non_sarcasm_emotions.items(), key=lambda x: x[1]) if non_sarcasm_emotions else (None, 0)
         
-        # Step 5: Normalize scores to ensure they sum to 1
+        if max_emotion[1] > 0.7:
+            # Very strong emotion detected - this could reduce sarcasm
+            emotion_scores['sarcasm'] *= 0.7
+            
+        # 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:
-            # 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()}
+        normalized_scores = {emotion: score / total_score for emotion, score in emotion_scores.items()}
         
         # Sort emotions by score
-        sorted_emotions = sorted(final_scores.items(), key=lambda x: x[1], reverse=True)
+        sorted_emotions = sorted(normalized_scores.items(), key=lambda x: x[1], reverse=True)
         emotions, scores = zip(*sorted_emotions)
         
+        # Prepare supporting evidence for each emotion
+        supporting_evidence = {}
+        for emotion in emotions:
+            evidence = []
+            
+            # Add detected phrases
+            if emotion_data[emotion].get('phrases'):
+                evidence.extend([f'Phrase: "{phrase}"' for phrase in emotion_data[emotion]['phrases']])
+                
+            # Add pattern matches for sarcasm
+            if emotion == 'sarcasm' and emotion_data['sarcasm'].get('patterns'):
+                evidence.extend([f'Pattern match: sarcastic pattern detected' for _ in emotion_data['sarcasm']['patterns']])
+                
+            # Add contextual features as evidence
+            if emotion == 'joy' and context_features['exclamations'] > 1:
+                evidence.append(f'Found {context_features["exclamations"]} exclamation marks (!)') 
+                
+            if emotion == 'anger' and context_features['capitalized_words'] > 0:
+                evidence.append(f'Found {context_features["capitalized_words"]} capitalized words')
+                
+            supporting_evidence[emotion] = evidence[:3]  # Limit to top 3 pieces of evidence
+        
         # Create visualization
-        fig = create_visualization(emotions, scores, text)
+        fig = create_visualization(emotions, scores, text, supporting_evidence)
         
         # Format output
         output = {
             "dominant_emotion": emotions[0],
             "confidence": f"{scores[0]*100:.1f}%",
-            "detailed_scores": {emotion: f"{score*100:.1f}%" for emotion, score in zip(emotions, scores)}
+            "detailed_scores": {emotion: f"{score*100:.1f}%" for emotion, score in zip(emotions, scores)},
+            "supporting_evidence": supporting_evidence
         }
         
         # 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"Sarcasm detected with {scores[0]*100:.1f}% confidence."
+        elif 'sarcasm' in normalized_scores and normalized_scores['sarcasm'] > 0.25:
             output["note"] = f"Some sarcastic elements detected alongside {emotions[0]}."
         
         return fig, output
@@ -412,9 +552,9 @@ def analyze_emotions(text):
         print(traceback.format_exc())
         return None, {"error": f"Analysis failed: {str(e)}"}
 
-def create_visualization(emotions, scores, text=None):
-    """Create a bar chart visualization of emotion scores"""
-    fig, ax = plt.subplots(figsize=(10, 6))
+def create_visualization(emotions, scores, text=None, supporting_evidence=None):
+    """Create a bar chart visualization of emotion scores with fixed x-axis and evidence"""
+    fig, ax = plt.subplots(figsize=(12, 7))
     
     # Use custom colors for the bars
     colors = [EMOTION_COLORS.get(emotion, '#1f77b4') for emotion in emotions]
@@ -422,10 +562,33 @@ def create_visualization(emotions, scores, text=None):
     # Create horizontal bar chart
     y_pos = np.arange(len(emotions))
     ax.barh(y_pos, [score * 100 for score in scores], color=colors)
+    
+    # Set fixed x-axis from 0 to 100
+    ax.set_xlim(0, 100)
+    ax.set_xticks(np.arange(0, 101, 10))
+    ax.set_xlabel('Confidence (%)')
+    
+    # Set y-ticks and labels
     ax.set_yticks(y_pos)
-    ax.set_yticklabels(emotions)
+    
+    # Create custom labels with probability
+    y_labels = []
+    for i, emotion in enumerate(emotions):
+        prob_text = f"{scores[i]*100:.1f}%"
+        y_labels.append(f"{emotion.capitalize()} ({prob_text})")
+        
+        # Add evidence as smaller text
+        if supporting_evidence and emotion in supporting_evidence and supporting_evidence[emotion]:
+            evidence_x = 101  # Position just outside the plot area
+            
+            for j, evidence in enumerate(supporting_evidence[emotion]):
+                ax.text(evidence_x, y_pos[i] - 0.15 + (j * 0.3), 
+                        evidence, 
+                        fontsize=8, color='#555555',
+                        verticalalignment='center')
+    
+    ax.set_yticklabels(y_labels)
     ax.invert_yaxis()  # Labels read top-to-bottom
-    ax.set_xlabel('Confidence (%)')
     
     # Add value labels to the bars
     for i, v in enumerate(scores):
@@ -456,7 +619,7 @@ demo = gr.Interface(
     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.""",
+    The analysis leverages BERT's contextual understanding along with phrase detection and linguistic 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."],
@@ -466,7 +629,9 @@ demo = gr.Interface(
         ["I deeply cherish the time we spend together."],
         ["Oh great, another meeting that could have been an email. Just what I needed today."],
         ["Sure, I'd LOVE to do your work for you. Nothing better than doing two jobs for one salary!"],
-        ["What a FANTASTIC way to start the day - my car won't start and it's pouring rain!"]
+        ["What a FANTASTIC way to start the day - my car won't start and it's pouring rain!"],
+        ["This new restaurant is absolutely mind-blowing. The flavors are incredible!"],
+        ["I'm heartbroken after hearing what happened. I can't believe it."]
     ],
     allow_flagging="never"
 )