Update app.py

app.py

@@ -12,23 +12,35 @@ import tempfile
 from datetime import datetime
 import pandas as pd
 from lime.lime_text import LimeTextExplainer
-import shap
 import logging
+from contextlib import contextmanager
+import gc
 
-# Simple Configuration
+# Enhanced Configuration
 class Config:
-    MAX_HISTORY = 500
+    MAX_HISTORY = 1000
     BATCH_LIMIT = 100
     THEMES = {
-        'default': {'pos': '#4CAF50', 'neg': '#F44336'},
-        'ocean': {'pos': '#2196F3', 'neg': '#FF5722'},
-        'dark': {'pos': '#00E676', 'neg': '#FF1744'}
+        'default': {'pos': '#4ecdc4', 'neg': '#ff6b6b'},
+        'ocean': {'pos': '#0077be', 'neg': '#ff6b35'},
+        'forest': {'pos': '#228b22', 'neg': '#dc143c'},
+        'sunset': {'pos': '#ff8c00', 'neg': '#8b0000'}
     }
 
 config = Config()
 logging.basicConfig(level=logging.INFO)
 
-# Model Manager - Simplified
+@contextmanager
+def managed_figure(*args, **kwargs):
+    """Context manager for matplotlib figures to prevent memory leaks"""
+    fig = plt.figure(*args, **kwargs)
+    try:
+        yield fig
+    finally:
+        plt.close(fig)
+        gc.collect()
+
+# Enhanced Model Manager
 class ModelManager:
     def __init__(self):
         self.custom_model = None
@@ -37,7 +49,6 @@ class ModelManager:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     
     def load_distilbert(self):
-        """Load DistilBERT for fast analysis"""
         if self.distilbert is None:
             self.distilbert = pipeline(
                 "sentiment-analysis", 
@@ -47,7 +58,6 @@ class ModelManager:
         return self.distilbert
     
     def load_custom_model(self):
-        """Load custom model for advanced analysis"""
         if self.custom_model is None:
             try:
                 self.custom_tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
@@ -59,13 +69,14 @@ class ModelManager:
                 raise
         return self.custom_model, self.custom_tokenizer
 
-# Simple History Manager
+# Enhanced History Manager
 class HistoryManager:
     def __init__(self):
         self.history = []
     
     def add(self, entry):
         entry['timestamp'] = datetime.now().isoformat()
+        entry['analysis_type'] = entry.get('analysis_type', 'single')
         self.history.append(entry)
         if len(self.history) > config.MAX_HISTORY:
             self.history = self.history[-config.MAX_HISTORY:]
@@ -73,6 +84,24 @@ class HistoryManager:
     def get_all(self):
         return self.history.copy()
     
+    def get_by_type(self, analysis_type):
+        return [h for h in self.history if h.get('analysis_type') == analysis_type]
+    
+    def get_stats(self):
+        if not self.history:
+            return {'total': 0, 'positive': 0, 'negative': 0, 'avg_confidence': 0}
+        
+        positive = sum(1 for h in self.history if h.get('sentiment') == 'Positive')
+        negative = len(self.history) - positive
+        avg_conf = np.mean([h.get('confidence', 0) for h in self.history])
+        
+        return {
+            'total': len(self.history),
+            'positive': positive,
+            'negative': negative,
+            'avg_confidence': avg_conf
+        }
+    
     def clear(self):
         count = len(self.history)
         self.history.clear()
@@ -81,44 +110,139 @@ class HistoryManager:
     def size(self):
         return len(self.history)
 
-# Core Analysis Engine
+# Enhanced Core Analysis Engine
 class SentimentEngine:
     def __init__(self):
         self.model_manager = ModelManager()
         self.lime_explainer = LimeTextExplainer(class_names=['Negative', 'Positive'])
     
-    # SINGLE ANALYSIS - DistilBERT with visualizations
+    def predict_proba_for_lime(self, texts):
+        """Prediction function for LIME using custom model"""
+        if isinstance(texts, str):
+            texts = [texts]
+        
+        model, tokenizer = self.model_manager.load_custom_model()
+        results = []
+        
+        for text in texts:
+            inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            inputs = {k: v.to(self.model_manager.device) for k, v in inputs.items()}
+            
+            with torch.no_grad():
+                outputs = model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+            results.append(probs)
+        
+        return np.array(results)
+    
+    def extract_keywords_lime(self, text, top_k=15):
+        """Enhanced keyword extraction using LIME"""
+        try:
+            explanation = self.lime_explainer.explain_instance(
+                text, self.predict_proba_for_lime, num_features=top_k*2, num_samples=200
+            )
+            
+            word_scores = []
+            for word, score in explanation.as_list():
+                if len(word.strip()) >= 2:
+                    word_scores.append((word.strip().lower(), score))
+            
+            # Sort by absolute importance
+            word_scores.sort(key=lambda x: abs(x[1]), reverse=True)
+            return word_scores[:top_k]
+            
+        except Exception as e:
+            logging.error(f"LIME extraction failed: {e}")
+            return []
+    
+    def create_heatmap_html(self, text, word_scores):
+        """Create enhanced HTML heatmap visualization"""
+        words = text.split()
+        html_parts = ['<div style="font-family: Arial; font-size: 16px; line-height: 1.8; padding: 10px; border: 1px solid #ddd; border-radius: 8px;">']
+        
+        # Create word score dictionary
+        score_dict = dict(word_scores) if word_scores else {}
+        
+        # Normalize scores for color intensity
+        if score_dict:
+            max_abs_score = max(abs(score) for score in score_dict.values())
+        else:
+            max_abs_score = 1
+        
+        for word in words:
+            clean_word = re.sub(r'[^\w]', '', word.lower())
+            score = score_dict.get(clean_word, 0)
+            
+            if score > 0:
+                # Positive contribution - green shades
+                intensity = min(0.8, abs(score) / max_abs_score) if max_abs_score > 0 else 0
+                color = f"rgba(76, 175, 80, {intensity})"
+                border_color = "#4CAF50"
+            elif score < 0:
+                # Negative contribution - red shades
+                intensity = min(0.8, abs(score) / max_abs_score) if max_abs_score > 0 else 0
+                color = f"rgba(244, 67, 54, {intensity})"
+                border_color = "#F44336"
+            else:
+                # Neutral - light gray
+                color = "rgba(158, 158, 158, 0.1)"
+                border_color = "transparent"
+            
+            html_parts.append(
+                f'<span style="background-color: {color}; padding: 3px 6px; margin: 2px; '
+                f'border-radius: 4px; border: 1px solid {border_color}; '
+                f'display: inline-block;" title="Impact Score: {score:.4f}">{word}</span> '
+            )
+        
+        html_parts.append('</div>')
+        html_parts.append('<div style="margin-top: 10px; font-size: 12px; color: #666;">')
+        html_parts.append('<span style="background: rgba(76, 175, 80, 0.6); padding: 2px 8px; margin: 0 5px;">Positive Impact</span>')
+        html_parts.append('<span style="background: rgba(244, 67, 54, 0.6); padding: 2px 8px; margin: 0 5px;">Negative Impact</span>')
+        html_parts.append('</div>')
+        
+        return ''.join(html_parts)
+    
+    # SINGLE ANALYSIS - Enhanced with detailed LIME
     def analyze_single(self, text, theme='default'):
-        """Single analysis with DistilBERT - fast and visual"""
         if not text.strip():
-            return "Please enter text", None, None, None
+            return "Please enter text", None, None, None, None, None
         
         try:
             # Use DistilBERT for fast analysis
             distilbert = self.model_manager.load_distilbert()
             result = distilbert(text)[0]
             
-            # Convert to our format
             sentiment = "Positive" if result['label'] == 'POSITIVE' else "Negative"
             confidence = result['score']
             pos_prob = confidence if sentiment == "Positive" else 1 - confidence
             neg_prob = 1 - pos_prob
             
+            # Enhanced keyword extraction with LIME
+            keywords = self.extract_keywords_lime(text)
+            
+            # Create heatmap
+            heatmap_html = self.create_heatmap_html(text, keywords)
+            
             # Create visualizations
             prob_chart = self._create_probability_chart([neg_prob, pos_prob], theme)
             confidence_gauge = self._create_confidence_gauge(confidence, sentiment, theme)
             wordcloud = self._create_wordcloud(text, sentiment, theme)
+            keyword_chart = self._create_keyword_chart(keywords, sentiment, theme)
             
-            result_text = f"Sentiment: {sentiment}\nConfidence: {confidence:.3f}"
+            # Enhanced result text
+            top_keywords = ", ".join([f"{word}({score:+.3f})" for word, score in keywords[:5]])
+            result_text = (f"Sentiment: {sentiment}\n"
+                          f"Confidence: {confidence:.3f}\n"
+                          f"Positive Probability: {pos_prob:.3f}\n"
+                          f"Top Keywords: {top_keywords}")
             
-            return result_text, prob_chart, confidence_gauge, wordcloud
+            return result_text, prob_chart, confidence_gauge, wordcloud, keyword_chart, heatmap_html
             
         except Exception as e:
-            return f"Analysis failed: {str(e)}", None, None, None
+            return f"Analysis failed: {str(e)}", None, None, None, None, None
     
-    # ADVANCED ANALYSIS - Custom model with SHAP/LIME
+    # ADVANCED ANALYSIS - Enhanced
     def analyze_advanced(self, text):
-        """Advanced analysis with custom model and explanations"""
         if not text.strip():
             return "Please enter text", None, None
         
@@ -136,28 +260,183 @@ class SentimentEngine:
             sentiment = "Positive" if probs[1] > probs[0] else "Negative"
             confidence = probs.max()
             
-            # Extract keywords using LIME
-            keywords = self._extract_keywords_lime(text, model, tokenizer)
+            # Enhanced keyword extraction
+            keywords = self.extract_keywords_lime(text, top_k=20)
             
-            # Create SHAP explanation
-            shap_html = self._create_shap_explanation(text, model, tokenizer)
+            # Create enhanced visualizations
+            keyword_chart = self._create_detailed_keyword_chart(keywords, sentiment)
+            heatmap_html = self.create_heatmap_html(text, keywords)
             
-            result_text = f"Sentiment: {sentiment}\nConfidence: {confidence:.3f}\n\nTop Keywords:\n"
-            result_text += "\n".join([f"• {word}: {score:.3f}" for word, score in keywords[:10]])
+            # Enhanced result text
+            result_text = f"Advanced Analysis Results:\n"
+            result_text += f"Sentiment: {sentiment} (Confidence: {confidence:.3f})\n"
+            result_text += f"Positive Probability: {probs[1]:.3f}\n"
+            result_text += f"Negative Probability: {probs[0]:.3f}\n\n"
+            result_text += f"Top Contributing Words:\n"
             
-            return result_text, shap_html, self._create_keyword_chart(keywords, sentiment)
+            for i, (word, score) in enumerate(keywords[:10], 1):
+                impact = "Positive" if score > 0 else "Negative"
+                result_text += f"{i:2}. {word:15} {score:+.4f} ({impact})\n"
+            
+            return result_text, heatmap_html, keyword_chart
             
         except Exception as e:
             return f"Advanced analysis failed: {str(e)}", None, None
     
-    # BATCH ANALYSIS - DistilBERT for efficiency
+    # Enhanced visualization methods
+    def _create_probability_chart(self, probs, theme):
+        with managed_figure(figsize=(8, 5)) as fig:
+            ax = fig.add_subplot(111)
+            colors = [config.THEMES[theme]['neg'], config.THEMES[theme]['pos']]
+            labels = ['Negative', 'Positive']
+            
+            bars = ax.bar(labels, probs, color=colors, alpha=0.8, edgecolor='white', linewidth=2)
+            ax.set_title('Sentiment Probabilities', fontsize=16, fontweight='bold', pad=20)
+            ax.set_ylabel('Probability', fontsize=12)
+            ax.set_ylim(0, 1)
+            ax.grid(axis='y', alpha=0.3)
+            
+            for bar, prob in zip(bars, probs):
+                ax.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.02,
+                       f'{prob:.3f}', ha='center', va='bottom', fontweight='bold', fontsize=12)
+            
+            return fig
+    
+    def _create_confidence_gauge(self, confidence, sentiment, theme):
+        with managed_figure(figsize=(8, 5)) as fig:
+            ax = fig.add_subplot(111)
+            
+            # Enhanced gauge design
+            theta = np.linspace(0, np.pi, 100)
+            r_outer = 1.0
+            r_inner = 0.7
+            
+            # Background gauge
+            ax.fill_between(theta, r_inner, r_outer, alpha=0.2, color='lightgray')
+            
+            # Confidence zones
+            low_zone = theta[theta <= np.pi/3]
+            med_zone = theta[(theta > np.pi/3) & (theta <= 2*np.pi/3)]
+            high_zone = theta[theta > 2*np.pi/3]
+            
+            ax.fill_between(low_zone, r_inner, r_outer, alpha=0.3, color='red', label='Low')
+            ax.fill_between(med_zone, r_inner, r_outer, alpha=0.3, color='orange', label='Medium')
+            ax.fill_between(high_zone, r_inner, r_outer, alpha=0.3, color='green', label='High')
+            
+            # Needle
+            angle = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
+            ax.plot([angle, angle], [0, r_outer*0.9], 'k-', linewidth=6)
+            ax.plot(angle, r_outer*0.9, 'ko', markersize=12)
+            
+            ax.set_xlim(0, np.pi)
+            ax.set_ylim(0, 1.2)
+            ax.set_title(f'{sentiment} Confidence: {confidence:.3f}', fontsize=16, fontweight='bold')
+            ax.axis('off')
+            
+            return fig
+    
+    def _create_keyword_chart(self, keywords, sentiment, theme):
+        if not keywords:
+            return None
+        
+        with managed_figure(figsize=(10, 6)) as fig:
+            ax = fig.add_subplot(111)
+            
+            words = [word for word, _ in keywords[:12]]
+            scores = [abs(score) for _, score in keywords[:12]]  # Use absolute values for bar height
+            colors = [config.THEMES[theme]['pos'] if keywords[i][1] > 0 
+                     else config.THEMES[theme]['neg'] for i in range(len(words))]
+            
+            bars = ax.barh(range(len(words)), scores, color=colors, alpha=0.7, edgecolor='white')
+            ax.set_yticks(range(len(words)))
+            ax.set_yticklabels(words)
+            ax.set_xlabel('Importance Score (Absolute)', fontsize=12)
+            ax.set_title(f'Top Contributing Words - {sentiment}', fontsize=14, fontweight='bold')
+            ax.invert_yaxis()
+            ax.grid(axis='x', alpha=0.3)
+            
+            # Add score labels
+            for i, (bar, score) in enumerate(zip(bars, scores)):
+                original_score = keywords[i][1]
+                ax.text(bar.get_width() + max(scores)*0.01, bar.get_y() + bar.get_height()/2.,
+                       f'{original_score:+.3f}', ha='left', va='center', fontsize=9)
+            
+            return fig
+    
+    def _create_detailed_keyword_chart(self, keywords, sentiment):
+        if not keywords:
+            return None
+        
+        with managed_figure(figsize=(12, 8)) as fig:
+            ax = fig.add_subplot(111)
+            
+            # Separate positive and negative keywords
+            pos_keywords = [(w, s) for w, s in keywords if s > 0]
+            neg_keywords = [(w, s) for w, s in keywords if s < 0]
+            
+            # Plot positive keywords (right side)
+            if pos_keywords:
+                pos_words = [w for w, _ in pos_keywords[:10]]
+                pos_scores = [s for _, s in pos_keywords[:10]]
+                y_pos = np.arange(len(pos_words))
+                
+                ax.barh(y_pos, pos_scores, alpha=0.7, color='#4ecdc4', 
+                       label=f'Positive Impact ({len(pos_keywords)} words)')
+                
+                for i, (word, score) in enumerate(zip(pos_words, pos_scores)):
+                    ax.text(score + max(pos_scores)*0.02, i, f'{score:.3f}', 
+                           va='center', fontsize=9)
+                
+                ax.set_yticks(y_pos)
+                ax.set_yticklabels(pos_words)
+            
+            # Plot negative keywords (left side)
+            if neg_keywords:
+                neg_words = [w for w, _ in neg_keywords[:10]]
+                neg_scores = [s for _, s in neg_keywords[:10]]
+                y_neg = np.arange(len(neg_words)) - len(pos_keywords) - 1
+                
+                ax.barh(y_neg, neg_scores, alpha=0.7, color='#ff6b6b', 
+                       label=f'Negative Impact ({len(neg_keywords)} words)')
+                
+                for i, (word, score) in enumerate(zip(neg_words, neg_scores)):
+                    ax.text(score - abs(min(neg_scores))*0.02, y_neg[i], f'{score:.3f}', 
+                           va='center', ha='right', fontsize=9)
+                
+                ax.set_yticks(y_neg)
+                ax.set_yticklabels(neg_words)
+            
+            ax.axvline(x=0, color='black', linestyle='-', alpha=0.3)
+            ax.set_xlabel('Impact Score', fontsize=12)
+            ax.set_title('Detailed Word Impact Analysis', fontsize=14, fontweight='bold')
+            ax.legend()
+            ax.grid(axis='x', alpha=0.3)
+            
+            return fig
+    
+    def _create_wordcloud(self, text, sentiment, theme):
+        if len(text.split()) < 5:
+            return None
+        
+        with managed_figure(figsize=(10, 6)) as fig:
+            ax = fig.add_subplot(111)
+            colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
+            
+            wc = WordCloud(width=800, height=400, background_color='white',
+                          colormap=colormap, max_words=50, relative_scaling=0.5).generate(text)
+            
+            ax.imshow(wc, interpolation='bilinear')
+            ax.axis('off')
+            ax.set_title(f'{sentiment} Word Cloud', fontsize=16, fontweight='bold')
+            
+            return fig
+    
+    # BATCH ANALYSIS - Keep existing but enhanced
     def analyze_batch(self, texts, progress_callback=None):
-        """Batch analysis with DistilBERT"""
         if not texts or len(texts) < 2:
             return None, "Need at least 2 texts for batch analysis"
         
         try:
-            # Limit batch size
             if len(texts) > config.BATCH_LIMIT:
                 texts = texts[:config.BATCH_LIMIT]
             
@@ -177,253 +456,175 @@ class SentimentEngine:
                         'text': text[:100] + "..." if len(text) > 100 else text,
                         'full_text': text,
                         'sentiment': sentiment,
-                        'confidence': confidence
+                        'confidence': confidence,
+                        'analysis_type': 'batch'
                     })
                 except:
                     continue
             
             if results:
-                chart = self._create_batch_chart(results)
-                return chart, f"Analyzed {len(results)} texts successfully"
+                chart = self._create_enhanced_batch_chart(results)
+                return chart, f"Successfully analyzed {len(results)} texts"
             else:
                 return None, "Batch analysis failed"
                 
         except Exception as e:
             return None, f"Batch analysis error: {str(e)}"
     
-    # Helper methods for visualizations
-    def _create_probability_chart(self, probs, theme):
-        """Create probability bar chart"""
-        fig, ax = plt.subplots(figsize=(8, 5))
-        colors = [config.THEMES[theme]['neg'], config.THEMES[theme]['pos']]
-        labels = ['Negative', 'Positive']
-        
-        bars = ax.bar(labels, probs, color=colors, alpha=0.8)
-        ax.set_title('Sentiment Probabilities', fontsize=16, fontweight='bold')
-        ax.set_ylabel('Probability')
-        ax.set_ylim(0, 1)
-        
-        # Add value labels
-        for bar, prob in zip(bars, probs):
-            ax.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.02,
-                   f'{prob:.3f}', ha='center', va='bottom', fontweight='bold')
-        
-        plt.tight_layout()
-        return fig
-    
-    def _create_confidence_gauge(self, confidence, sentiment, theme):
-        """Create confidence gauge"""
-        fig, ax = plt.subplots(figsize=(8, 5))
-        
-        # Create semi-circular gauge
-        theta = np.linspace(0, np.pi, 100)
-        r = 1
-        
-        # Background
-        ax.fill_between(theta, 0, r, alpha=0.3, color='lightgray')
-        
-        # Confidence indicator
-        conf_theta = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
-        ax.plot([conf_theta, conf_theta], [0, r], 'k-', linewidth=8)
-        ax.plot(conf_theta, r, 'ko', markersize=12)
-        
-        ax.set_xlim(0, np.pi)
-        ax.set_ylim(0, 1.2)
-        ax.set_title(f'{sentiment} - Confidence: {confidence:.3f}', fontsize=16, fontweight='bold')
-        ax.set_xticks([0, np.pi/2, np.pi])
-        ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
-        ax.axis('off')
-        
-        plt.tight_layout()
-        return fig
-    
-    def _create_wordcloud(self, text, sentiment, theme):
-        """Create word cloud"""
-        if len(text.split()) < 5:
-            return None
-        
-        fig, ax = plt.subplots(figsize=(10, 6))
-        colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
-        
-        wc = WordCloud(width=800, height=400, background_color='white',
-                      colormap=colormap, max_words=50).generate(text)
-        
-        ax.imshow(wc, interpolation='bilinear')
-        ax.axis('off')
-        ax.set_title(f'{sentiment} Word Cloud', fontsize=16, fontweight='bold')
-        
-        plt.tight_layout()
-        return fig
-    
-    def _extract_keywords_lime(self, text, model, tokenizer):
-        """Extract keywords using LIME"""
-        try:
-            def predict_proba(texts):
-                results = []
-                for text in texts:
-                    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
-                    inputs = {k: v.to(self.model_manager.device) for k, v in inputs.items()}
-                    with torch.no_grad():
-                        outputs = model(**inputs)
-                        probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
-                    results.append(probs)
-                return np.array(results)
-            
-            explanation = self.lime_explainer.explain_instance(
-                text, predict_proba, num_features=20, num_samples=100
-            )
-            
-            return [(word, abs(score)) for word, score in explanation.as_list()]
-            
-        except Exception as e:
-            logging.error(f"LIME extraction failed: {e}")
-            return []
-    
-    def _create_shap_explanation(self, text, model, tokenizer):
-        """Create SHAP explanation HTML"""
-        try:
-            # Simple word highlighting based on attention
-            words = text.split()
-            html_parts = ['<div style="font-family: Arial; font-size: 16px; line-height: 1.8;">']
-            
-            for word in words:
-                # Simple heuristic for demonstration
-                if any(pos_word in word.lower() for pos_word in ['good', 'great', 'excellent', 'amazing']):
-                    color = 'rgba(76, 175, 80, 0.3)'
-                elif any(neg_word in word.lower() for neg_word in ['bad', 'terrible', 'awful', 'horrible']):
-                    color = 'rgba(244, 67, 54, 0.3)'
-                else:
-                    color = 'transparent'
-                
-                html_parts.append(
-                    f'<span style="background-color: {color}; padding: 2px; margin: 1px; '
-                    f'border-radius: 3px;">{word}</span> '
-                )
-            
-            html_parts.append('</div>')
-            return ''.join(html_parts)
-            
-        except Exception as e:
-            return f"SHAP explanation failed: {str(e)}"
-    
-    def _create_keyword_chart(self, keywords, sentiment):
-        """Create keyword importance chart"""
-        if not keywords:
-            return None
-        
-        fig, ax = plt.subplots(figsize=(10, 6))
-        words = [word for word, _ in keywords[:15]]
-        scores = [score for _, score in keywords[:15]]
-        
-        color = config.THEMES['default']['pos'] if sentiment == 'Positive' else config.THEMES['default']['neg']
-        bars = ax.barh(range(len(words)), scores, color=color, alpha=0.7)
-        
-        ax.set_yticks(range(len(words)))
-        ax.set_yticklabels(words)
-        ax.set_xlabel('Importance Score')
-        ax.set_title(f'Top Keywords - {sentiment}', fontsize=16, fontweight='bold')
-        ax.invert_yaxis()
-        
-        plt.tight_layout()
-        return fig
-    
-    def _create_batch_chart(self, results):
-        """Create batch analysis visualization"""
-        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
-        
-        # Sentiment distribution
-        sent_counts = Counter([r['sentiment'] for r in results])
-        colors = [config.THEMES['default']['pos'], config.THEMES['default']['neg']]
-        ax1.pie(sent_counts.values(), labels=sent_counts.keys(), autopct='%1.1f%%', colors=colors)
-        ax1.set_title('Sentiment Distribution')
-        
-        # Confidence distribution
-        confidences = [r['confidence'] for r in results]
-        ax2.hist(confidences, bins=15, alpha=0.7, color='skyblue', edgecolor='black')
-        ax2.set_title('Confidence Distribution')
-        ax2.set_xlabel('Confidence Score')
-        
-        # Sentiment over sequence
-        sentiments = [1 if r['sentiment'] == 'Positive' else 0 for r in results]
-        ax3.plot(sentiments, marker='o', alpha=0.7)
-        ax3.set_title('Sentiment Sequence')
-        ax3.set_ylabel('Sentiment (0=Neg, 1=Pos)')
-        ax3.set_xlabel('Review Index')
-        
-        # Top words
-        all_text = ' '.join([r['full_text'] for r in results])
-        words = re.findall(r'\b\w{3,}\b', all_text.lower())
-        word_counts = Counter(words).most_common(10)
-        
-        if word_counts:
-            words, counts = zip(*word_counts)
-            ax4.bar(range(len(words)), counts, alpha=0.7)
-            ax4.set_xticks(range(len(words)))
-            ax4.set_xticklabels(words, rotation=45)
-            ax4.set_title('Most Frequent Words')
-        
-        plt.tight_layout()
-        return fig
+    def _create_enhanced_batch_chart(self, results):
+        with managed_figure(figsize=(15, 10)) as fig:
+            gs = fig.add_gridspec(2, 3, hspace=0.3, wspace=0.3)
+            
+            # Sentiment distribution pie
+            ax1 = fig.add_subplot(gs[0, 0])
+            sent_counts = Counter([r['sentiment'] for r in results])
+            colors = ['#4ecdc4' if sent == 'Positive' else '#ff6b6b' for sent in sent_counts.keys()]
+            wedges, texts, autotexts = ax1.pie(sent_counts.values(), labels=sent_counts.keys(), 
+                                              autopct='%1.1f%%', colors=colors, startangle=90)
+            ax1.set_title('Sentiment Distribution', fontweight='bold')
+            
+            # Confidence histogram
+            ax2 = fig.add_subplot(gs[0, 1])
+            confidences = [r['confidence'] for r in results]
+            ax2.hist(confidences, bins=15, alpha=0.7, color='skyblue', edgecolor='black')
+            ax2.set_title('Confidence Distribution', fontweight='bold')
+            ax2.set_xlabel('Confidence Score')
+            ax2.set_ylabel('Frequency')
+            ax2.grid(axis='y', alpha=0.3)
+            
+            # Sentiment vs Confidence scatter
+            ax3 = fig.add_subplot(gs[0, 2])
+            pos_results = [r for r in results if r['sentiment'] == 'Positive']
+            neg_results = [r for r in results if r['sentiment'] == 'Negative']
+            
+            if pos_results:
+                ax3.scatter([1]*len(pos_results), [r['confidence'] for r in pos_results], 
+                           c='#4ecdc4', alpha=0.6, s=50, label='Positive')
+            if neg_results:
+                ax3.scatter([0]*len(neg_results), [r['confidence'] for r in neg_results], 
+                           c='#ff6b6b', alpha=0.6, s=50, label='Negative')
+            
+            ax3.set_xlim(-0.5, 1.5)
+            ax3.set_ylim(0, 1)
+            ax3.set_xticks([0, 1])
+            ax3.set_xticklabels(['Negative', 'Positive'])
+            ax3.set_ylabel('Confidence')
+            ax3.set_title('Sentiment vs Confidence', fontweight='bold')
+            ax3.legend()
+            ax3.grid(alpha=0.3)
+            
+            # Sentiment sequence
+            ax4 = fig.add_subplot(gs[1, :])
+            sentiments = [1 if r['sentiment'] == 'Positive' else 0 for r in results]
+            confidences = [r['confidence'] for r in results]
+            colors = ['#4ecdc4' if s == 1 else '#ff6b6b' for s in sentiments]
+            
+            scatter = ax4.scatter(range(len(results)), sentiments, c=colors, s=confidences*100, alpha=0.7)
+            ax4.set_title('Sentiment Sequence (bubble size = confidence)', fontweight='bold')
+            ax4.set_ylabel('Sentiment')
+            ax4.set_xlabel('Review Index')
+            ax4.set_yticks([0, 1])
+            ax4.set_yticklabels(['Negative', 'Positive'])
+            ax4.grid(alpha=0.3)
+            
+            return fig
 
-# File Processor
+# Enhanced File Processor
 class FileProcessor:
     @staticmethod
     def process_file(file):
-        """Simple file processing"""
         if not file:
             return ""
         
         try:
             if file.name.endswith('.csv'):
-                df = pd.read_csv(file.name)
-                # Find text column
-                text_col = None
-                for col in df.columns:
-                    if df[col].dtype == 'object':
-                        text_col = col
+                # Try multiple encodings
+                for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                    try:
+                        df = pd.read_csv(file.name, encoding=encoding)
+                        
+                        # Smart column detection
+                        text_columns = []
+                        for col in df.columns:
+                            sample_values = df[col].dropna().head(10)
+                            if len(sample_values) > 0:
+                                text_count = sum(1 for val in sample_values 
+                                               if isinstance(val, str) and len(str(val).strip()) > 10)
+                                if text_count > len(sample_values) * 0.7:
+                                    text_columns.append(col)
+                        
+                        selected_column = text_columns[0] if text_columns else df.columns[0]
+                        texts = df[selected_column].dropna().astype(str).tolist()
+                        
+                        # Filter and clean
+                        cleaned_texts = []
+                        for text in texts:
+                            text = text.strip()
+                            if len(text) > 10 and text.lower() != 'nan':
+                                cleaned_texts.append(text)
+                        
+                        if cleaned_texts:
+                            return '\n'.join(cleaned_texts)
                         break
+                        
+                    except Exception:
+                        continue
                 
-                if text_col:
-                    texts = df[text_col].dropna().astype(str).tolist()
-                    return '\n'.join([t for t in texts if len(t.strip()) > 10])
+                return "Error: Could not process CSV file"
             
             else:
-                with open(file.name, 'r', encoding='utf-8') as f:
-                    return f.read()
-        
+                # Handle text files
+                for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                    try:
+                        with open(file.name, 'r', encoding=encoding) as f:
+                            return f.read().strip()
+                    except Exception:
+                        continue
+                
+                return "Error: Could not read text file"
+                
         except Exception as e:
-            return f"File processing failed: {str(e)}"
-        
-        return ""
+            return f"File processing error: {str(e)}"
 
-# Data Exporter
+# Enhanced Data Exporter
 class DataExporter:
     @staticmethod
     def export_csv(data):
-        """Export to CSV"""
         if not data:
             return None, "No data to export"
         
         try:
             temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv')
             writer = csv.writer(temp_file)
-            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence'])
+            
+            # Enhanced headers
+            writer.writerow(['Timestamp', 'Text_Preview', 'Full_Text', 'Sentiment', 
+                           'Confidence', 'Analysis_Type', 'Top_Keywords'])
             
             for entry in data:
+                # Extract top keywords if available
+                keywords_str = ""
+                if 'key_words' in entry and entry['key_words']:
+                    keywords_str = "; ".join([f"{word}:{score:.3f}" 
+                                            for word, score in entry['key_words'][:5]])
+                
                 writer.writerow([
                     entry.get('timestamp', ''),
                     entry.get('text', ''),
+                    entry.get('full_text', entry.get('text', '')),
                     entry.get('sentiment', ''),
-                    f"{entry.get('confidence', 0):.4f}"
+                    f"{entry.get('confidence', 0):.4f}",
+                    entry.get('analysis_type', 'single'),
+                    keywords_str
                 ])
             
             temp_file.close()
-            return temp_file.name, f"Exported {len(data)} entries"
+            return temp_file.name, f"Exported {len(data)} entries with enhanced data"
         
         except Exception as e:
             return None, f"Export failed: {str(e)}"
 
-# Main Application
+# Enhanced Main Application
 class SentimentApp:
     def __init__(self):
         self.engine = SentimentEngine()
@@ -431,7 +632,6 @@ class SentimentApp:
         self.file_processor = FileProcessor()
         self.exporter = DataExporter()
         
-        # Sample examples
         self.examples = [
             "This movie was absolutely fantastic! The acting was superb and the plot kept me engaged throughout.",
             "Terrible film with poor acting and a confusing storyline. Complete waste of time.",
@@ -439,18 +639,102 @@ class SentimentApp:
             "An masterpiece of cinema! Every scene was beautifully crafted and emotionally powerful.",
             "The worst movie I've ever seen. Bad acting, terrible script, and boring plot."
         ]
+    
+    def create_history_trends(self, theme='default'):
+        """Enhanced history visualization"""
+        history = self.history.get_all()
+        if len(history) < 2:
+            return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
+        
+        with managed_figure(figsize=(14, 10)) as fig:
+            gs = fig.add_gridspec(3, 2, hspace=0.4, wspace=0.3)
+            
+            # Extract data
+            timestamps = [datetime.fromisoformat(h['timestamp']) for h in history]
+            sentiments = [h.get('sentiment', 'Unknown') for h in history]
+            confidences = [h.get('confidence', 0) for h in history]
+            analysis_types = [h.get('analysis_type', 'single') for h in history]
+            
+            # 1. Sentiment timeline
+            ax1 = fig.add_subplot(gs[0, :])
+            pos_mask = [s == 'Positive' for s in sentiments]
+            neg_mask = [s == 'Negative' for s in sentiments]
+            
+            pos_times = [t for t, m in zip(timestamps, pos_mask) if m]
+            neg_times = [t for t, m in zip(timestamps, neg_mask) if m]
+            pos_confs = [c for c, m in zip(confidences, pos_mask) if m]
+            neg_confs = [c for c, m in zip(confidences, neg_mask) if m]
+            
+            if pos_times:
+                ax1.scatter(pos_times, [1]*len(pos_times), c='#4ecdc4', s=[c*100 for c in pos_confs], 
+                           alpha=0.7, label='Positive', edgecolors='white')
+            if neg_times:
+                ax1.scatter(neg_times, [0]*len(neg_times), c='#ff6b6b', s=[c*100 for c in neg_confs], 
+                           alpha=0.7, label='Negative', edgecolors='white')
+            
+            ax1.set_ylim(-0.5, 1.5)
+            ax1.set_yticks([0, 1])
+            ax1.set_yticklabels(['Negative', 'Positive'])
+            ax1.set_title('Sentiment Timeline (bubble size = confidence)', fontweight='bold', fontsize=14)
+            ax1.legend()
+            ax1.grid(alpha=0.3)
+            
+            # 2. Confidence trends
+            ax2 = fig.add_subplot(gs[1, 0])
+            colors = ['#4ecdc4' if s == 'Positive' else '#ff6b6b' for s in sentiments]
+            ax2.plot(range(len(confidences)), confidences, 'o-', alpha=0.7, markersize=6)
+            ax2.scatter(range(len(confidences)), confidences, c=colors, s=60, alpha=0.8, edgecolors='white')
+            ax2.set_title('Confidence Trends', fontweight='bold')
+            ax2.set_xlabel('Analysis Number')
+            ax2.set_ylabel('Confidence Score')
+            ax2.grid(alpha=0.3)
+            
+            # 3. Analysis type distribution
+            ax3 = fig.add_subplot(gs[1, 1])
+            type_counts = Counter(analysis_types)
+            colors_pie = ['#2E86C1', '#28B463', '#F39C12'][:len(type_counts)]
+            ax3.pie(type_counts.values(), labels=type_counts.keys(), autopct='%1.1f%%', 
+                   colors=colors_pie, startangle=90)
+            ax3.set_title('Analysis Types', fontweight='bold')
+            
+            # 4. Statistics summary
+            ax4 = fig.add_subplot(gs[2, :])
+            stats = self.history.get_stats()
+            
+            # Create summary text
+            summary_text = f"""
+Analysis Summary:
+• Total Analyses: {stats['total']}
+• Positive Reviews: {stats['positive']} ({stats['positive']/stats['total']*100:.1f}%)
+• Negative Reviews: {stats['negative']} ({stats['negative']/stats['total']*100:.1f}%)
+• Average Confidence: {stats['avg_confidence']:.3f}
+
+Recent Activity:
+• Last 10 analyses: {len(history[-10:])} entries
+• Most recent: {history[-1]['sentiment'] if history else 'None'}
+            """
+            
+            ax4.text(0.1, 0.5, summary_text, transform=ax4.transAxes, fontsize=12,
+                    verticalalignment='center', bbox=dict(boxstyle="round,pad=0.3", 
+                    facecolor='lightblue', alpha=0.3))
+            ax4.set_xlim(0, 1)
+            ax4.set_ylim(0, 1)
+            ax4.axis('off')
+            ax4.set_title('Statistics Summary', fontweight='bold')
+            
+            return fig, f"History trends generated for {len(history)} analyses"
 
 def create_interface():
-    """Create the Gradio interface"""
+    """Create enhanced Gradio interface"""
     app = SentimentApp()
     
-    with gr.Blocks(theme=gr.themes.Soft(), title="Sentiment Analysis Suite") as demo:
-        gr.Markdown("# 🎭 Movie Sentiment Analysis Suite")
-        gr.Markdown("**Three specialized analysis modes: Single, Advanced, and Batch processing**")
+    with gr.Blocks(theme=gr.themes.Soft(), title="Enhanced Movie Sentiment Analyzer") as demo:
+        gr.Markdown("# 🎭 Enhanced Movie Sentiment Analyzer")
+        gr.Markdown("**Advanced sentiment analysis with LIME explanations, keyword extraction, and comprehensive visualizations**")
         
-        # TAB 1: SINGLE ANALYSIS
+        # TAB 1: SINGLE ANALYSIS - Enhanced
         with gr.Tab("🎯 Single Analysis"):
-            gr.Markdown("### Fast analysis with DistilBERT + Rich visualizations")
+            gr.Markdown("### Fast DistilBERT analysis with enhanced LIME keyword extraction")
             
             with gr.Row():
                 with gr.Column():
@@ -464,7 +748,7 @@ def create_interface():
                         theme_dropdown = gr.Dropdown(
                             choices=list(config.THEMES.keys()),
                             value="default",
-                            label="Theme"
+                            label="Color Theme"
                         )
                     
                     gr.Examples(
@@ -473,99 +757,138 @@ def create_interface():
                     )
                 
                 with gr.Column():
-                    single_result = gr.Textbox(label="Analysis Result", lines=4)
+                    single_result = gr.Textbox(label="Analysis Results", lines=6)
+                    heatmap_display = gr.HTML(label="Word Importance Heatmap")
             
             with gr.Row():
-                prob_plot = gr.Plot(label="Probability Distribution")
+                prob_plot = gr.Plot(label="Sentiment Probabilities")
                 confidence_plot = gr.Plot(label="Confidence Gauge")
             
-            wordcloud_plot = gr.Plot(label="Word Cloud Visualization")
+            with gr.Row():
+                wordcloud_plot = gr.Plot(label="Word Cloud")
+                keyword_plot = gr.Plot(label="Key Contributing Words")
         
-        # TAB 2: ADVANCED ANALYSIS  
+        # TAB 2: ADVANCED ANALYSIS - Enhanced
         with gr.Tab("🧠 Advanced Analysis"):
-            gr.Markdown("### Deep analysis with custom model + SHAP/LIME explanations")
+            gr.Markdown("### Deep BERT analysis with detailed LIME explanations and keyword impact")
             
             with gr.Row():
                 with gr.Column():
                     advanced_input = gr.Textbox(
                         label="Text for Deep Analysis",
-                        placeholder="Enter text for detailed analysis...",
+                        placeholder="Enter text for comprehensive analysis...",
                         lines=6
                     )
                     advanced_btn = gr.Button("Deep Analyze", variant="primary", size="lg")
                 
                 with gr.Column():
-                    advanced_result = gr.Textbox(label="Detailed Results", lines=8)
+                    advanced_result = gr.Textbox(label="Detailed Analysis Results", lines=12)
             
             with gr.Row():
-                shap_output = gr.HTML(label="SHAP Explanation")
-                keyword_plot = gr.Plot(label="Key Contributing Words")
+                advanced_heatmap = gr.HTML(label="Enhanced Word Impact Heatmap")
+                advanced_keywords = gr.Plot(label="Detailed Keyword Analysis")
         
-        # TAB 3: BATCH ANALYSIS
+        # TAB 3: BATCH ANALYSIS - Enhanced
         with gr.Tab("📊 Batch Analysis"):
-            gr.Markdown("### Efficient batch processing with DistilBERT")
+            gr.Markdown("### Enhanced batch processing with comprehensive statistics")
             
             with gr.Row():
                 with gr.Column():
-                    file_upload = gr.File(label="Upload CSV/TXT file")
+                    file_upload = gr.File(
+                        label="Upload CSV/TXT File", 
+                        file_types=[".csv", ".txt"]
+                    )
                     batch_input = gr.Textbox(
-                        label="Batch Text (one review per line)",
+                        label="Batch Reviews (one per line)",
                         placeholder="Paste multiple reviews, one per line...",
                         lines=8
                     )
                 
                 with gr.Column():
-                    load_file_btn = gr.Button("Load File")
+                    load_file_btn = gr.Button("Load File", variant="secondary")
                     batch_btn = gr.Button("Analyze Batch", variant="primary", size="lg")
-                    batch_status = gr.Textbox(label="Status", lines=2)
+                    batch_status = gr.Textbox(label="Batch Status", lines=2)
             
-            batch_plot = gr.Plot(label="Batch Analysis Results")
+            batch_plot = gr.Plot(label="Enhanced Batch Analysis Results")
         
-        # TAB 4: HISTORY & EXPORT
-        with gr.Tab("📈 History & Export"):
-            gr.Markdown("### Analysis history and data export")
+        # TAB 4: ENHANCED HISTORY & EXPORT
+        with gr.Tab("📈 History & Analytics"):
+            gr.Markdown("### Comprehensive analysis history with advanced statistics and trends")
             
             with gr.Row():
-                refresh_btn = gr.Button("Refresh History")
-                clear_btn = gr.Button("Clear History", variant="stop")
-                status_display = gr.Textbox(label="History Status", value="Ready")
+                with gr.Column():
+                    with gr.Row():
+                        refresh_history_btn = gr.Button("Refresh History", variant="secondary")
+                        clear_history_btn = gr.Button("Clear All History", variant="stop")
+                    
+                    history_stats = gr.Textbox(
+                        label="History Statistics", 
+                        lines=3,
+                        value="No analyses yet"
+                    )
+                
+                with gr.Column():
+                    with gr.Row():
+                        export_csv_btn = gr.Button("Export CSV", variant="secondary")
+                        export_json_btn = gr.Button("Export JSON", variant="secondary")
+                    
+                    export_status = gr.Textbox(label="Export Status", lines=2)
             
-            with gr.Row():
-                export_csv_btn = gr.Button("Export as CSV", variant="secondary")
-                export_file = gr.File(label="Download Export")
+            # Enhanced history visualization
+            history_trends_plot = gr.Plot(label="Advanced History Trends & Analytics")
             
-            history_plot = gr.Plot(label="Analysis Trends")
+            # File downloads
+            with gr.Row():
+                csv_download = gr.File(label="CSV Download", visible=False)
+                json_download = gr.File(label="JSON Download", visible=False)
         
-        # Event handlers
-        def single_analysis_handler(text, theme):
-            result_text, prob_fig, conf_fig, cloud_fig = app.engine.analyze_single(text, theme)
+        # Enhanced Event Handlers
+        def enhanced_single_analysis(text, theme):
+            result_text, prob_fig, conf_fig, cloud_fig, keyword_fig, heatmap_html = app.engine.analyze_single(text, theme)
             
-            # Add to history
-            if "failed" not in result_text.lower():
-                app.history.add({
-                    'text': text[:100],
-                    'full_text': text,
-                    'sentiment': result_text.split('\n')[0].split(': ')[1] if ': ' in result_text else 'Unknown',
-                    'confidence': float(result_text.split('Confidence: ')[1]) if 'Confidence: ' in result_text else 0.0
-                })
+            # Add enhanced data to history
+            if "failed" not in result_text.lower() and text.strip():
+                # Extract keywords for history (simplified)
+                try:
+                    keywords = app.engine.extract_keywords_lime(text, top_k=10)
+                    app.history.add({
+                        'text': text[:100],
+                        'full_text': text,
+                        'sentiment': result_text.split('\n')[0].split(': ')[1] if ': ' in result_text else 'Unknown',
+                        'confidence': float(result_text.split('Confidence: ')[1].split('\n')[0]) if 'Confidence: ' in result_text else 0.0,
+                        'analysis_type': 'single',
+                        'key_words': keywords
+                    })
+                except:
+                    pass
             
-            return result_text, prob_fig, conf_fig, cloud_fig
+            return result_text, prob_fig, conf_fig, cloud_fig, keyword_fig, heatmap_html
         
-        def advanced_analysis_handler(text):
-            result_text, shap_html, keyword_fig = app.engine.analyze_advanced(text)
+        def enhanced_advanced_analysis(text):
+            result_text, heatmap_html, keyword_fig = app.engine.analyze_advanced(text)
             
-            # Add to history
-            if "failed" not in result_text.lower():
-                app.history.add({
-                    'text': text[:100],
-                    'full_text': text,
-                    'sentiment': result_text.split('\n')[0].split(': ')[1] if ': ' in result_text else 'Unknown',
-                    'confidence': float(result_text.split('Confidence: ')[1].split('\n')[0]) if 'Confidence: ' in result_text else 0.0
-                })
+            # Add to history with enhanced data
+            if "failed" not in result_text.lower() and text.strip():
+                try:
+                    keywords = app.engine.extract_keywords_lime(text, top_k=15)
+                    sentiment = result_text.split('Sentiment: ')[1].split(' (')[0] if 'Sentiment: ' in result_text else 'Unknown'
+                    confidence_str = result_text.split('Confidence: ')[1].split(')')[0] if 'Confidence: ' in result_text else '0'
+                    confidence = float(confidence_str)
+                    
+                    app.history.add({
+                        'text': text[:100],
+                        'full_text': text,
+                        'sentiment': sentiment,
+                        'confidence': confidence,
+                        'analysis_type': 'advanced',
+                        'key_words': keywords
+                    })
+                except:
+                    pass
             
-            return result_text, shap_html, keyword_fig
+            return result_text, heatmap_html, keyword_fig
         
-        def batch_analysis_handler(text):
+        def enhanced_batch_analysis(text):
             if not text.strip():
                 return None, "Please provide text for batch analysis"
             
@@ -575,29 +898,68 @@ def create_interface():
             
             chart, status = app.engine.analyze_batch(texts)
             
-            # Add successful results to history
-            if chart and "successfully" in status:
-                for text in texts:
-                    app.history.add({
-                        'text': text[:100],
-                        'full_text': text,
-                        'sentiment': 'Batch',
-                        'confidence': 0.0
-                    })
+            # Add results to history
+            if chart and "Successfully" in status:
+                for review_text in texts:
+                    # Quick analysis for history
+                    try:
+                        distilbert = app.engine.model_manager.load_distilbert()
+                        result = distilbert(review_text)[0]
+                        sentiment = "Positive" if result['label'] == 'POSITIVE' else "Negative"
+                        confidence = result['score']
+                        
+                        app.history.add({
+                            'text': review_text[:100],
+                            'full_text': review_text,
+                            'sentiment': sentiment,
+                            'confidence': confidence,
+                            'analysis_type': 'batch'
+                        })
+                    except:
+                        continue
             
             return chart, status
         
-        # Bind events
+        def get_history_stats():
+            stats = app.history.get_stats()
+            if stats['total'] == 0:
+                return "No analyses performed yet"
+            
+            return f"""Current Statistics:
+• Total Analyses: {stats['total']}
+• Positive: {stats['positive']} ({stats['positive']/stats['total']*100:.1f}%)
+• Negative: {stats['negative']} ({stats['negative']/stats['total']*100:.1f}%)
+• Average Confidence: {stats['avg_confidence']:.3f}"""
+        
+        def export_csv_data():
+            file_path, message = app.exporter.export_csv(app.history.get_all())
+            return file_path, message
+        
+        def export_json_data():
+            # Create JSON export
+            data = app.history.get_all()
+            if not data:
+                return None, "No data to export"
+            
+            try:
+                temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json')
+                json.dump(data, temp_file, indent=2, ensure_ascii=False, default=str)
+                temp_file.close()
+                return temp_file.name, f"Exported {len(data)} entries as JSON"
+            except Exception as e:
+                return None, f"JSON export failed: {str(e)}"
+        
+        # Bind enhanced events
         single_btn.click(
-            single_analysis_handler,
+            enhanced_single_analysis,
             inputs=[single_input, theme_dropdown],
-            outputs=[single_result, prob_plot, confidence_plot, wordcloud_plot]
+            outputs=[single_result, prob_plot, confidence_plot, wordcloud_plot, keyword_plot, heatmap_display]
         )
         
         advanced_btn.click(
-            advanced_analysis_handler,
+            enhanced_advanced_analysis,
             inputs=advanced_input,
-            outputs=[advanced_result, shap_output, keyword_plot]
+            outputs=[advanced_result, advanced_heatmap, advanced_keywords]
         )
         
         load_file_btn.click(
@@ -607,31 +969,42 @@ def create_interface():
         )
         
         batch_btn.click(
-            batch_analysis_handler,
+            enhanced_batch_analysis,
             inputs=batch_input,
             outputs=[batch_plot, batch_status]
         )
         
-        refresh_btn.click(
-            lambda: f"History: {app.history.size()} analyses",
-            outputs=status_display
+        refresh_history_btn.click(
+            lambda: [app.create_history_trends()[0], get_history_stats()],
+            outputs=[history_trends_plot, history_stats]
         )
         
-        clear_btn.click(
-            lambda: f"Cleared {app.history.clear()} entries",
-            outputs=status_display
+        clear_history_btn.click(
+            lambda: [None, f"Cleared {app.history.clear()} entries", "History cleared"],
+            outputs=[history_trends_plot, export_status, history_stats]
         )
         
         export_csv_btn.click(
-            lambda: app.exporter.export_csv(app.history.get_all()),
-            outputs=[export_file, status_display]
+            export_csv_data,
+            outputs=[csv_download, export_status]
+        )
+        
+        export_json_btn.click(
+            export_json_data,
+            outputs=[json_download, export_status]
+        )
+        
+        # Auto-refresh history stats on load
+        demo.load(
+            get_history_stats,
+            outputs=history_stats
         )
     
     return demo
 
-# Launch the application
+# Launch Enhanced Application
 if __name__ == "__main__":
-    logging.info("Starting Sentiment Analysis Suite...")
+    logging.info("Starting Enhanced Sentiment Analysis Suite...")
     demo = create_interface()
     demo.launch(
         share=True,