Update app.py

app.py

@@ -1,9 +1,7 @@
 import torch
 import gradio as gr
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import plotly.graph_objects as go
-import plotly.express as px
-from plotly.subplots import make_subplots
+from transformers import BertTokenizer, BertForSequenceClassification
+import matplotlib.pyplot as plt
 import numpy as np
 from wordcloud import WordCloud
 from collections import Counter, defaultdict
@@ -18,10 +16,6 @@ from functools import lru_cache, wraps
 from dataclasses import dataclass
 from typing import List, Dict, Optional, Tuple, Any, Callable
 from contextlib import contextmanager
-import nltk
-from nltk.corpus import stopwords
-import langdetect
-import pandas as pd
 import gc
 
 # Configuration
@@ -34,45 +28,27 @@ class Config:
     CACHE_SIZE: int = 128
     BATCH_PROCESSING_SIZE: int = 8
     
-    # Supported languages and models
-    SUPPORTED_LANGUAGES = {
-        'auto': 'Auto Detect',
-        'en': 'English',
-        'zh': 'Chinese',
-        'es': 'Spanish',
-        'fr': 'French',
-        'de': 'German',
-        'sv': 'Swedish'
-    }
+    # Visualization settings
+    FIGURE_SIZE_SINGLE: Tuple[int, int] = (8, 5)
+    FIGURE_SIZE_BATCH: Tuple[int, int] = (12, 8)
+    WORDCLOUD_SIZE: Tuple[int, int] = (10, 5)
     
-    MODELS = {
-        'en': "cardiffnlp/twitter-roberta-base-sentiment-latest",
-        'multilingual': "cardiffnlp/twitter-xlm-roberta-base-sentiment",
-        'zh': "uer/roberta-base-finetuned-dianping-chinese"
+    THEMES = {
+        'default': {'pos': '#4ecdc4', 'neg': '#ff6b6b'},
+        'ocean': {'pos': '#0077be', 'neg': '#ff6b35'},
+        'forest': {'pos': '#228b22', 'neg': '#dc143c'},
+        'sunset': {'pos': '#ff8c00', 'neg': '#8b0000'}
     }
     
-    # Color themes for Plotly
-    THEMES = {
-        'default': {'pos': '#4CAF50', 'neg': '#F44336', 'neu': '#FF9800'},
-        'ocean': {'pos': '#0077BE', 'neg': '#FF6B35', 'neu': '#00BCD4'},
-        'dark': {'pos': '#66BB6A', 'neg': '#EF5350', 'neu': '#FFA726'},
-        'rainbow': {'pos': '#9C27B0', 'neg': '#E91E63', 'neu': '#FF5722'}
+    STOP_WORDS = {
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
+        'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 
+        'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should'
     }
 
 config = Config()
-
-# Logging setup
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize NLTK
-try:
-    nltk.download('stopwords', quiet=True)
-    nltk.download('punkt', quiet=True)
-    STOP_WORDS = set(stopwords.words('english'))
-except:
-    STOP_WORDS = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
-
 # Decorators and Context Managers
 def handle_errors(default_return=None):
     """Centralized error handling decorator"""
@@ -88,11 +64,13 @@ def handle_errors(default_return=None):
     return decorator
 
 @contextmanager
-def memory_cleanup():
-    """Context manager for memory cleanup"""
+def managed_figure(*args, **kwargs):
+    """Context manager for matplotlib figures to prevent memory leaks"""
+    fig = plt.figure(*args, **kwargs)
     try:
-        yield
+        yield fig
     finally:
+        plt.close(fig)
         gc.collect()
 
 class ThemeContext:
@@ -101,152 +79,72 @@ class ThemeContext:
         self.theme = theme
         self.colors = config.THEMES.get(theme, config.THEMES['default'])
 
-# Enhanced Model Manager with Multi-language Support
+# Lazy Model Manager
 class ModelManager:
-    """Multi-language model manager with lazy loading"""
+    """Lazy loading model manager"""
     _instance = None
+    _model = None
+    _tokenizer = None
+    _device = None
     
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
         return cls._instance
     
-    def __init__(self):
-        if not self._initialized:
-            self.models = {}
-            self.tokenizers = {}
-            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            self._load_default_models()
-            self._initialized = True
-    
-    def _load_default_models(self):
-        """Load default models"""
+    @property
+    def model(self):
+        if self._model is None:
+            self._load_model()
+        return self._model
+    
+    @property
+    def tokenizer(self):
+        if self._tokenizer is None:
+            self._load_model()
+        return self._tokenizer
+    
+    @property
+    def device(self):
+        if self._device is None:
+            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        return self._device
+    
+    def _load_model(self):
+        """Load model and tokenizer"""
         try:
-            # Load multilingual model as default
-            model_name = config.MODELS['multilingual']
-            self.tokenizers['default'] = AutoTokenizer.from_pretrained(model_name)
-            self.models['default'] = AutoModelForSequenceClassification.from_pretrained(model_name)
-            self.models['default'].to(self.device)
-            logger.info(f"Default model loaded: {model_name}")
-            
-            # Load Chinese model
-            zh_model_name = config.MODELS['zh']
-            self.tokenizers['zh'] = AutoTokenizer.from_pretrained(zh_model_name)
-            self.models['zh'] = AutoModelForSequenceClassification.from_pretrained(zh_model_name)
-            self.models['zh'].to(self.device)
-            logger.info(f"Chinese model loaded: {zh_model_name}")
-            
+            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self._tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
+            self._model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis")
+            self._model.to(self._device)
+            logger.info(f"Model loaded on {self._device}")
         except Exception as e:
-            logger.error(f"Failed to load models: {e}")
+            logger.error(f"Model loading failed: {e}")
             raise
-    
-    def get_model(self, language='en'):
-        """Get model for specific language"""
-        if language == 'zh':
-            return self.models['zh'], self.tokenizers['zh']
-        return self.models['default'], self.tokenizers['default']
-    
-    @staticmethod
-    def detect_language(text: str) -> str:
-        """Detect text language"""
-        try:
-            detected = langdetect.detect(text)
-            language_mapping = {
-                'zh-cn': 'zh',
-                'zh-tw': 'zh'
-            }
-            detected = language_mapping.get(detected, detected)
-            return detected if detected in config.SUPPORTED_LANGUAGES else 'en'
-        except:
-            return 'en'
 
-# Simplified Text Processing
+# Simplified Core Classes
 class TextProcessor:
-    """Optimized text processing with multi-language support"""
-    
+    """Optimized text processing"""
     @staticmethod
     @lru_cache(maxsize=config.CACHE_SIZE)
-    def clean_text(text: str, remove_punctuation: bool = True, remove_numbers: bool = False) -> str:
-        """Clean text with language awareness"""
-        text = text.strip()
-        
-        # Don't clean Chinese text aggressively
-        if re.search(r'[\u4e00-\u9fff]', text):
-            return text
-        
-        text = text.lower()
-        
-        if remove_numbers:
-            text = re.sub(r'\d+', '', text)
-        
-        if remove_punctuation:
-            text = re.sub(r'[^\w\s]', '', text)
-        
-        words = text.split()
-        cleaned_words = [w for w in words if w not in STOP_WORDS and len(w) >= config.MIN_WORD_LENGTH]
-        return ' '.join(cleaned_words)
-    
-    @staticmethod
-    def extract_keywords(text: str, top_k: int = 5) -> List[str]:
-        """Extract keywords with language support"""
-        if re.search(r'[\u4e00-\u9fff]', text):
-            # Chinese text processing
-            words = re.findall(r'[\u4e00-\u9fff]+', text)
-            all_chars = ''.join(words)
-            char_freq = Counter(all_chars)
-            return [char for char, _ in char_freq.most_common(top_k)]
-        else:
-            # Other languages
-            cleaned = TextProcessor.clean_text(text)
-            words = cleaned.split()
-            word_freq = Counter(words)
-            return [word for word, _ in word_freq.most_common(top_k)]
-    
-    @staticmethod
-    def parse_batch_input(text: str) -> List[str]:
-        """Parse batch input from textarea"""
-        lines = text.strip().split('\n')
-        return [line.strip() for line in lines if line.strip()]
+    def clean_text(text: str) -> Tuple[str, ...]:
+        """Single-pass text cleaning"""
+        words = re.findall(r'\b\w{3,}\b', text.lower())
+        return tuple(w for w in words if w not in config.STOP_WORDS)
 
-# Enhanced History Manager
 class HistoryManager:
-    """Enhanced history management with filtering"""
+    """Simplified history management"""
     def __init__(self):
         self._history = []
     
     def add(self, entry: Dict):
-        """Add entry with timestamp"""
-        entry['timestamp'] = datetime.now().isoformat()
-        self._history.append(entry)
+        self._history.append({**entry, 'timestamp': datetime.now().isoformat()})
         if len(self._history) > config.MAX_HISTORY_SIZE:
             self._history = self._history[-config.MAX_HISTORY_SIZE:]
     
-    def add_batch(self, entries: List[Dict]):
-        """Add multiple entries"""
-        for entry in entries:
-            self.add(entry)
-    
     def get_all(self) -> List[Dict]:
         return self._history.copy()
     
-    def get_recent(self, n: int = 10) -> List[Dict]:
-        return self._history[-n:] if self._history else []
-    
-    def filter_by(self, sentiment: str = None, language: str = None, 
-                  min_confidence: float = None) -> List[Dict]:
-        """Filter history by criteria"""
-        filtered = self._history
-        
-        if sentiment:
-            filtered = [h for h in filtered if h['sentiment'] == sentiment]
-        if language:
-            filtered = [h for h in filtered if h.get('language', 'en') == language]
-        if min_confidence:
-            filtered = [h for h in filtered if h['confidence'] >= min_confidence]
-            
-        return filtered
-    
     def clear(self) -> int:
         count = len(self._history)
         self._history.clear()
@@ -254,175 +152,107 @@ class HistoryManager:
     
     def size(self) -> int:
         return len(self._history)
-    
-    def get_stats(self) -> Dict:
-        """Get comprehensive statistics"""
-        if not self._history:
-            return {}
-        
-        sentiments = [item['sentiment'] for item in self._history]
-        confidences = [item['confidence'] for item in self._history]
-        languages = [item.get('language', 'en') for item in self._history]
-        
-        return {
-            'total_analyses': len(self._history),
-            'positive_count': sentiments.count('Positive'),
-            'negative_count': sentiments.count('Negative'),
-            'neutral_count': sentiments.count('Neutral'),
-            'avg_confidence': np.mean(confidences),
-            'max_confidence': np.max(confidences),
-            'min_confidence': np.min(confidences),
-            'languages_detected': len(set(languages)),
-            'most_common_language': Counter(languages).most_common(1)[0][0] if languages else 'en'
-        }
 
-# Core Sentiment Analysis Engine
+# Core Analysis Engine
 class SentimentEngine:
-    """Multi-language sentiment analysis engine"""
-    
+    """Streamlined sentiment analysis with attention-based keyword extraction"""
     def __init__(self):
         self.model_manager = ModelManager()
     
-    def extract_attention_keywords(self, text: str, language: str = 'auto', top_k: int = 10) -> List[Tuple[str, float]]:
-        """Extract keywords using attention weights"""
+    def extract_key_words(self, text: str, top_k: int = 10) -> List[Tuple[str, float]]:
+        """Extract contributing words using BERT attention weights"""
         try:
-            if language == 'auto':
-                language = self.model_manager.detect_language(text)
-            
-            model, tokenizer = self.model_manager.get_model(language)
-            
-            inputs = tokenizer(
+            inputs = self.model_manager.tokenizer(
                 text, return_tensors="pt", padding=True, 
                 truncation=True, max_length=config.MAX_TEXT_LENGTH
             ).to(self.model_manager.device)
             
+            # Get model outputs with attention weights
             with torch.no_grad():
-                outputs = model(**inputs, output_attentions=True)
+                outputs = self.model_manager.model(**inputs, output_attentions=True)
+                attention = outputs.attentions  # Tuple of attention tensors for each layer
                 
-                if hasattr(outputs, 'attentions') and outputs.attentions:
-                    # Use attention weights
-                    attention = outputs.attentions[-1]
-                    avg_attention = attention.mean(dim=1)[0, 0, :]
-                    
-                    tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
-                    attention_scores = avg_attention.cpu().numpy()
-                    
-                    # Process tokens and scores
-                    word_scores = {}
-                    current_word = ""
-                    current_score = 0.0
-                    
-                    for token, score in zip(tokens, attention_scores):
-                        if token in ['[CLS]', '[SEP]', '[PAD]', '<s>', '</s>']:
-                            continue
-                            
-                        if token.startswith('##') or token.startswith('▁'):
-                            current_word += token.replace('##', '').replace('▁', '')
-                            current_score = max(current_score, score)
-                        else:
-                            if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
-                                word_scores[current_word.lower()] = current_score
-                            current_word = token
-                            current_score = score
+                # Use the last layer's attention, average over all heads
+                last_attention = attention[-1]  # Shape: [batch_size, num_heads, seq_len, seq_len]
+                avg_attention = last_attention.mean(dim=1)  # Average over heads: [batch_size, seq_len, seq_len]
+                
+                # Focus on attention to [CLS] token (index 0) as it represents the whole sequence
+                cls_attention = avg_attention[0, 0, :]  # Attention from CLS to all tokens
+                
+            # Get tokens and their attention scores
+            tokens = self.model_manager.tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
+            attention_scores = cls_attention.cpu().numpy()
+            
+            # Filter out special tokens and combine subword tokens
+            word_scores = {}
+            current_word = ""
+            current_score = 0.0
+            
+            for i, (token, score) in enumerate(zip(tokens, attention_scores)):
+                if token in ['[CLS]', '[SEP]', '[PAD]']:
+                    continue
                     
+                if token.startswith('##'):
+                    # Subword token, add to current word
+                    current_word += token[2:]
+                    current_score = max(current_score, score)  # Take max attention
+                else:
+                    # New word, save previous if exists
                     if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
                         word_scores[current_word.lower()] = current_score
                     
-                    # Filter and sort
-                    filtered_words = {
-                        word: score for word, score in word_scores.items() 
-                        if word not in STOP_WORDS and len(word) >= config.MIN_WORD_LENGTH
-                    }
-                    
-                    sorted_words = sorted(filtered_words.items(), key=lambda x: x[1], reverse=True)
-                    return sorted_words[:top_k]
-                
+                    current_word = token
+                    current_score = score
+            
+            # Don't forget the last word
+            if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
+                word_scores[current_word.lower()] = current_score
+            
+            # Filter out stop words and sort by attention score
+            filtered_words = {
+                word: score for word, score in word_scores.items() 
+                if word not in config.STOP_WORDS and len(word) >= config.MIN_WORD_LENGTH
+            }
+            
+            # Sort by attention score and return top_k
+            sorted_words = sorted(filtered_words.items(), key=lambda x: x[1], reverse=True)
+            return sorted_words[:top_k]
+            
         except Exception as e:
-            logger.error(f"Attention keyword extraction failed: {e}")
-        
-        # Fallback to simple keyword extraction
-        keywords = TextProcessor.extract_keywords(text, top_k)
-        return [(word, 0.1) for word in keywords]
+            logger.error(f"Key word extraction failed: {e}")
+            return []
     
-    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'keywords': []})
-    def analyze_single(self, text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
-        """Analyze single text with enhanced features"""
+    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'key_words': []})
+    def analyze_single(self, text: str) -> Dict:
+        """Analyze single text with key word extraction"""
         if not text.strip():
-            raise ValueError("Empty text provided")
-        
-        # Detect language
-        if language == 'auto':
-            detected_lang = self.model_manager.detect_language(text)
-        else:
-            detected_lang = language
-        
-        # Get appropriate model
-        model, tokenizer = self.model_manager.get_model(detected_lang)
-        
-        # Preprocessing
-        options = preprocessing_options or {}
-        processed_text = text
-        if options.get('clean_text', False) and not re.search(r'[\u4e00-\u9fff]', text):
-            processed_text = TextProcessor.clean_text(
-                text, 
-                options.get('remove_punctuation', True),
-                options.get('remove_numbers', False)
-            )
+            raise ValueError("Empty text")
         
-        # Tokenize and analyze
-        inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
-                         truncation=True, max_length=config.MAX_TEXT_LENGTH).to(self.model_manager.device)
+        inputs = self.model_manager.tokenizer(
+            text, return_tensors="pt", padding=True, 
+            truncation=True, max_length=config.MAX_TEXT_LENGTH
+        ).to(self.model_manager.device)
         
         with torch.no_grad():
-            outputs = model(**inputs)
+            outputs = self.model_manager.model(**inputs)
             probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
         
-        # Handle different model outputs
-        if len(probs) == 3:  # negative, neutral, positive
-            sentiment_idx = np.argmax(probs)
-            sentiment_labels = ['Negative', 'Neutral', 'Positive']
-            sentiment = sentiment_labels[sentiment_idx]
-            confidence = float(probs[sentiment_idx])
-            
-            result = {
-                'sentiment': sentiment,
-                'confidence': confidence,
-                'neg_prob': float(probs[0]),
-                'neu_prob': float(probs[1]),
-                'pos_prob': float(probs[2]),
-                'has_neutral': True
-            }
-        else:  # negative, positive
-            pred = np.argmax(probs)
-            sentiment = "Positive" if pred == 1 else "Negative"
-            confidence = float(probs[pred])
-            
-            result = {
-                'sentiment': sentiment,
-                'confidence': confidence,
-                'neg_prob': float(probs[0]),
-                'pos_prob': float(probs[1]),
-                'neu_prob': 0.0,
-                'has_neutral': False
-            }
+        sentiment = "Positive" if probs[1] > probs[0] else "Negative"
         
-        # Extract keywords
-        keywords = self.extract_attention_keywords(text, detected_lang)
+        # Extract key contributing words
+        key_words = self.extract_key_words(text)
         
-        # Add metadata
-        result.update({
-            'language': detected_lang,
-            'keywords': keywords,
-            'word_count': len(text.split()),
-            'char_count': len(text)
-        })
-        
-        return result
+        return {
+            'sentiment': sentiment,
+            'confidence': float(probs.max()),
+            'pos_prob': float(probs[1]),
+            'neg_prob': float(probs[0]),
+            'key_words': key_words
+        }
     
     @handle_errors(default_return=[])
-    def analyze_batch(self, texts: List[str], language: str = 'auto', 
-                     preprocessing_options: Dict = None, progress_callback=None) -> List[Dict]:
-        """Optimized batch processing"""
+    def analyze_batch(self, texts: List[str], progress_callback=None) -> List[Dict]:
+        """Optimized batch processing with key words"""
         if len(texts) > config.BATCH_SIZE_LIMIT:
             texts = texts[:config.BATCH_SIZE_LIMIT]
         
@@ -435,263 +265,185 @@ class SentimentEngine:
             if progress_callback:
                 progress_callback((i + len(batch)) / len(texts))
             
-            for text in batch:
-                try:
-                    result = self.analyze_single(text, language, preprocessing_options)
-                    result['batch_index'] = len(results)
-                    result['text'] = text[:100] + '...' if len(text) > 100 else text
-                    result['full_text'] = text
-                    results.append(result)
-                except Exception as e:
-                    results.append({
-                        'sentiment': 'Error',
-                        'confidence': 0.0,
-                        'error': str(e),
-                        'batch_index': len(results),
-                        'text': text[:100] + '...' if len(text) > 100 else text,
-                        'full_text': text
-                    })
+            inputs = self.model_manager.tokenizer(
+                batch, return_tensors="pt", padding=True, 
+                truncation=True, max_length=config.MAX_TEXT_LENGTH
+            ).to(self.model_manager.device)
+            
+            with torch.no_grad():
+                outputs = self.model_manager.model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
+            
+            for text, prob in zip(batch, probs):
+                sentiment = "Positive" if prob[1] > prob[0] else "Negative"
+                # Extract key words for each text in batch
+                key_words = self.extract_key_words(text, top_k=5)  # Fewer for batch processing
+                
+                results.append({
+                    'text': text[:50] + '...' if len(text) > 50 else text,
+                    'full_text': text,
+                    'sentiment': sentiment,
+                    'confidence': float(prob.max()),
+                    'pos_prob': float(prob[1]),
+                    'neg_prob': float(prob[0]),
+                    'key_words': key_words
+                })
         
         return results
 
-# Advanced Plotly Visualization System
-class PlotlyVisualizer:
-    """Enhanced Plotly visualizations"""
+# Unified Visualization System
+class PlotFactory:
+    """Factory for creating plots with proper memory management"""
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_sentiment_gauge(result: Dict, theme: ThemeContext) -> go.Figure:
-        """Create animated sentiment gauge"""
-        colors = theme.colors
-        
-        if result.get('has_neutral', False):
-            # Three-way gauge
-            fig = go.Figure(go.Indicator(
-                mode="gauge+number+delta",
-                value=result['pos_prob'] * 100,
-                domain={'x': [0, 1], 'y': [0, 1]},
-                title={'text': f"Sentiment: {result['sentiment']}"},
-                delta={'reference': 50},
-                gauge={
-                    'axis': {'range': [None, 100]},
-                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
-                    'steps': [
-                        {'range': [0, 33], 'color': colors['neg']},
-                        {'range': [33, 67], 'color': colors['neu']},
-                        {'range': [67, 100], 'color': colors['pos']}
-                    ],
-                    'threshold': {
-                        'line': {'color': "red", 'width': 4},
-                        'thickness': 0.75,
-                        'value': 90
-                    }
-                }
-            ))
-        else:
-            # Two-way gauge
-            fig = go.Figure(go.Indicator(
-                mode="gauge+number",
-                value=result['confidence'] * 100,
-                domain={'x': [0, 1], 'y': [0, 1]},
-                title={'text': f"Confidence: {result['sentiment']}"},
-                gauge={
-                    'axis': {'range': [None, 100]},
-                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
-                    'steps': [
-                        {'range': [0, 50], 'color': "lightgray"},
-                        {'range': [50, 100], 'color': "gray"}
-                    ]
-                }
-            ))
-        
-        fig.update_layout(height=400, font={'size': 16})
-        return fig
-    
-    @staticmethod
-    @handle_errors(default_return=None)
-    def create_probability_bars(result: Dict, theme: ThemeContext) -> go.Figure:
-        """Create probability bar chart"""
-        colors = theme.colors
-        
-        if result.get('has_neutral', False):
-            labels = ['Negative', 'Neutral', 'Positive']
-            values = [result['neg_prob'], result['neu_prob'], result['pos_prob']]
-            bar_colors = [colors['neg'], colors['neu'], colors['pos']]
-        else:
-            labels = ['Negative', 'Positive']
-            values = [result['neg_prob'], result['pos_prob']]
-            bar_colors = [colors['neg'], colors['pos']]
-        
-        fig = go.Figure(data=[
-            go.Bar(x=labels, y=values, marker_color=bar_colors, 
-                   text=[f'{v:.3f}' for v in values], textposition='outside')
-        ])
-        
-        fig.update_layout(
-            title="Sentiment Probabilities",
-            yaxis_title="Probability",
-            height=400,
-            showlegend=False
-        )
-        
-        return fig
+    def create_sentiment_bars(probs: np.ndarray, theme: ThemeContext) -> plt.Figure:
+        """Create sentiment probability bars"""
+        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
+            ax = fig.add_subplot(111)
+            labels = ["Negative", "Positive"]
+            colors = [theme.colors['neg'], theme.colors['pos']]
+            
+            bars = ax.bar(labels, probs, color=colors, alpha=0.8)
+            ax.set_title("Sentiment Probabilities", 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')
+            
+            fig.tight_layout()
+            return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_keyword_chart(keywords: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> go.Figure:
-        """Create keyword importance chart"""
-        if not keywords:
-            fig = go.Figure()
-            fig.add_annotation(text="No keywords extracted", 
-                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
-            fig.update_layout(height=400, title="Keywords")
+    def create_confidence_gauge(confidence: float, sentiment: str, theme: ThemeContext) -> plt.Figure:
+        """Create confidence gauge"""
+        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
+            ax = fig.add_subplot(111)
+            
+            # Create gauge
+            theta = np.linspace(0, np.pi, 100)
+            colors = [theme.colors['neg'] if i < 50 else theme.colors['pos'] for i in range(100)]
+            
+            for i in range(len(theta)-1):
+                ax.fill_between([theta[i], theta[i+1]], [0, 0], [0.8, 0.8], 
+                               color=colors[i], alpha=0.7)
+            
+            # Needle position
+            pos = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
+            ax.plot([pos, pos], [0, 0.6], 'k-', linewidth=6)
+            ax.plot(pos, 0.6, 'ko', markersize=10)
+            
+            ax.set_xlim(0, np.pi)
+            ax.set_ylim(0, 1)
+            ax.set_title(f'{sentiment} - Confidence: {confidence:.3f}', fontweight='bold')
+            ax.set_xticks([0, np.pi/2, np.pi])
+            ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
+            ax.axis('off')
+            
+            fig.tight_layout()
             return fig
-        
-        words = [word for word, score in keywords]
-        scores = [score for word, score in keywords]
-        
-        color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
-        
-        fig = go.Figure(data=[
-            go.Bar(
-                y=words,
-                x=scores,
-                orientation='h',
-                marker_color=color,
-                text=[f'{score:.3f}' for score in scores],
-                textposition='auto'
-            )
-        ])
-        
-        fig.update_layout(
-            title=f"Top Keywords ({sentiment})",
-            xaxis_title="Attention Weight",
-            yaxis_title="Keywords",
-            height=400,
-            showlegend=False
-        )
-        
-        return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_batch_summary(results: List[Dict], theme: ThemeContext) -> go.Figure:
-        """Create batch analysis summary"""
-        colors = theme.colors
-        
-        # Count sentiments
-        sentiments = [r['sentiment'] for r in results if 'sentiment' in r and r['sentiment'] != 'Error']
-        sentiment_counts = Counter(sentiments)
-        
-        # Create pie chart
-        fig = go.Figure(data=[go.Pie(
-            labels=list(sentiment_counts.keys()),
-            values=list(sentiment_counts.values()),
-            marker_colors=[colors.get(s.lower()[:3], '#999999') for s in sentiment_counts.keys()],
-            textinfo='label+percent',
-            hole=0.3
-        )])
-        
-        fig.update_layout(
-            title=f"Batch Analysis Summary ({len(results)} texts)",
-            height=400
-        )
-        
-        return fig
+    def create_keyword_chart(key_words: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
+        """Create horizontal bar chart for key contributing words"""
+        if not key_words:
+            return None
+        
+        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
+            ax = fig.add_subplot(111)
+            
+            words = [word for word, score in key_words]
+            scores = [score for word, score in key_words]
+            
+            # Choose color based on sentiment
+            color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
+            
+            # Create horizontal bar chart
+            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('Attention Weight')
+            ax.set_title(f'Top Contributing Words ({sentiment})', fontweight='bold')
+            
+            # Add value labels on bars
+            for i, (bar, score) in enumerate(zip(bars, scores)):
+                ax.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2.,
+                       f'{score:.3f}', ha='left', va='center', fontsize=9)
+            
+            # Invert y-axis to show highest scoring word at top
+            ax.invert_yaxis()
+            ax.grid(axis='x', alpha=0.3)
+            fig.tight_layout()
+            return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_confidence_distribution(results: List[Dict]) -> go.Figure:
-        """Create confidence distribution plot"""
-        confidences = [r['confidence'] for r in results if 'confidence' in r and r['sentiment'] != 'Error']
-        
-        if not confidences:
-            return go.Figure()
-        
-        fig = go.Figure(data=[go.Histogram(
-            x=confidences,
-            nbinsx=20,
-            marker_color='skyblue',
-            opacity=0.7
-        )])
-        
-        fig.update_layout(
-            title="Confidence Distribution",
-            xaxis_title="Confidence Score",
-            yaxis_title="Frequency",
-            height=400
-        )
-        
-        return fig
+    def create_wordcloud(text: str, sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
+        """Create word cloud"""
+        if len(text.split()) < 3:
+            return None
+        
+        colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
+        wc = WordCloud(width=800, height=400, background_color='white',
+                      colormap=colormap, max_words=30).generate(text)
+        
+        with managed_figure(figsize=config.WORDCLOUD_SIZE) as fig:
+            ax = fig.add_subplot(111)
+            ax.imshow(wc, interpolation='bilinear')
+            ax.axis('off')
+            ax.set_title(f'{sentiment} Word Cloud', fontweight='bold')
+            fig.tight_layout()
+            return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_history_dashboard(history: List[Dict], theme: ThemeContext) -> go.Figure:
-        """Create comprehensive history dashboard"""
-        if len(history) < 2:
-            return go.Figure()
-        
-        # Create subplots
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=['Sentiment Timeline', 'Confidence Distribution', 
-                           'Language Distribution', 'Sentiment Summary'],
-            specs=[[{"secondary_y": False}, {"secondary_y": False}],
-                   [{"type": "pie"}, {"type": "bar"}]]
-        )
-        
-        # Extract data
-        indices = list(range(len(history)))
-        pos_probs = [item.get('pos_prob', 0) for item in history]
-        confidences = [item['confidence'] for item in history]
-        sentiments = [item['sentiment'] for item in history]
-        languages = [item.get('language', 'en') for item in history]
-        
-        # Sentiment timeline
-        colors_map = {'Positive': theme.colors['pos'], 'Negative': theme.colors['neg'], 'Neutral': theme.colors['neu']}
-        colors = [colors_map.get(s, '#999999') for s in sentiments]
-        
-        fig.add_trace(
-            go.Scatter(x=indices, y=pos_probs, mode='lines+markers', 
-                      marker=dict(color=colors, size=8),
-                      name='Positive Probability'),
-            row=1, col=1
-        )
-        
-        # Confidence distribution
-        fig.add_trace(
-            go.Histogram(x=confidences, nbinsx=10, name='Confidence'),
-            row=1, col=2
-        )
-        
-        # Language distribution
-        lang_counts = Counter(languages)
-        fig.add_trace(
-            go.Pie(labels=list(lang_counts.keys()), values=list(lang_counts.values()),
-                   name="Languages"),
-            row=2, col=1
-        )
-        
-        # Sentiment summary
-        sent_counts = Counter(sentiments)
-        sent_colors = [colors_map.get(k, '#999999') for k in sent_counts.keys()]
-        fig.add_trace(
-            go.Bar(x=list(sent_counts.keys()), y=list(sent_counts.values()),
-                   marker_color=sent_colors),
-            row=2, col=2
-        )
-        
-        fig.update_layout(height=800, showlegend=False)
-        return fig
+    def create_batch_analysis(results: List[Dict], theme: ThemeContext) -> plt.Figure:
+        """Create comprehensive batch visualization"""
+        with managed_figure(figsize=config.FIGURE_SIZE_BATCH) as fig:
+            gs = fig.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
+            
+            # Sentiment distribution
+            ax1 = fig.add_subplot(gs[0, 0])
+            sent_counts = Counter([r['sentiment'] for r in results])
+            colors = [theme.colors['pos'], theme.colors['neg']]
+            ax1.pie(sent_counts.values(), labels=sent_counts.keys(), 
+                   autopct='%1.1f%%', colors=colors[:len(sent_counts)])
+            ax1.set_title('Sentiment Distribution')
+            
+            # Confidence histogram
+            ax2 = fig.add_subplot(gs[0, 1])
+            confs = [r['confidence'] for r in results]
+            ax2.hist(confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
+            ax2.set_title('Confidence Distribution')
+            ax2.set_xlabel('Confidence')
+            
+            # Sentiment over time
+            ax3 = fig.add_subplot(gs[1, :])
+            pos_probs = [r['pos_prob'] for r in results]
+            indices = range(len(results))
+            colors_scatter = [theme.colors['pos'] if r['sentiment'] == 'Positive' 
+                            else theme.colors['neg'] for r in results]
+            ax3.scatter(indices, pos_probs, c=colors_scatter, alpha=0.7, s=60)
+            ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+            ax3.set_title('Sentiment Progression')
+            ax3.set_xlabel('Review Index')
+            ax3.set_ylabel('Positive Probability')
+            
+            return fig
 
-# Universal Data Handler
+# Unified Data Handler
 class DataHandler:
-    """Enhanced data operations"""
+    """Handles all data operations"""
     
     @staticmethod
     @handle_errors(default_return=(None, "Export failed"))
     def export_data(data: List[Dict], format_type: str) -> Tuple[Optional[str], str]:
-        """Export data with comprehensive information"""
+        """Universal data export"""
         if not data:
             return None, "No data to export"
         
@@ -700,21 +452,16 @@ class DataHandler:
         
         if format_type == 'csv':
             writer = csv.writer(temp_file)
-            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Language', 
-                           'Pos_Prob', 'Neg_Prob', 'Neu_Prob', 'Keywords', 'Word_Count'])
+            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Pos_Prob', 'Neg_Prob', 'Key_Words'])
             for entry in data:
-                keywords_str = "|".join([f"{word}:{score:.3f}" for word, score in entry.get('keywords', [])])
                 writer.writerow([
                     entry.get('timestamp', ''),
                     entry.get('text', ''),
                     entry.get('sentiment', ''),
                     f"{entry.get('confidence', 0):.4f}",
-                    entry.get('language', 'en'),
                     f"{entry.get('pos_prob', 0):.4f}",
                     f"{entry.get('neg_prob', 0):.4f}",
-                    f"{entry.get('neu_prob', 0):.4f}",
-                    keywords_str,
-                    entry.get('word_count', 0)
+                    "|".join([f"{word}:{score:.3f}" for word, score in entry.get('key_words', [])])
                 ])
         elif format_type == 'json':
             json.dump(data, temp_file, indent=2, ensure_ascii=False)
@@ -722,29 +469,31 @@ class DataHandler:
         temp_file.close()
         return temp_file.name, f"Exported {len(data)} entries"
     
+
     @staticmethod
     @handle_errors(default_return="")
     def process_file(file) -> str:
-        """Process uploaded files"""
+        """Process uploaded file"""
         if not file:
             return ""
-        
+    
         content = file.read().decode('utf-8')
         
         if file.name.endswith('.csv'):
+            import io
             csv_file = io.StringIO(content)
             reader = csv.reader(csv_file)
             try:
-                next(reader)  # Skip header
+                next(reader)
                 texts = []
                 for row in reader:
                     if row and row[0].strip():
                         text = row[0].strip().strip('"')
-                        if text:
+                        if text:  
                             texts.append(text)
                 return '\n'.join(texts)
-            except:
-                lines = content.strip().split('\n')[1:]
+            except Exception as e:
+                lines = content.strip().split('\n')[1:] 
                 texts = []
                 for line in lines:
                     if line.strip():
@@ -752,762 +501,227 @@ class DataHandler:
                         if text:
                             texts.append(text)
                 return '\n'.join(texts)
-        
         return content
 
-# Main Application Class
+# Main Application
 class SentimentApp:
-    """Main multilingual sentiment analysis application"""
+    """Main application orchestrator"""
     
     def __init__(self):
         self.engine = SentimentEngine()
         self.history = HistoryManager()
         self.data_handler = DataHandler()
         
-        # Multi-language examples
+        # Example data
         self.examples = [
-            ["This movie was absolutely fantastic! The acting was superb and the plot kept me engaged throughout."],
-            ["The film was disappointing with poor character development and a confusing storyline."],
-            ["这部电影真的很棒！演技精湛，情节引人入胜。"],  # Chinese
-            ["Esta película fue increíble, me encantó la cinematografía."],  # Spanish
-            ["Ce film était magnifique, j'ai adoré la réalisation."],  # French
+            ["While the film's visual effects were undeniably impressive, the story lacked emotional weight, and the pacing felt inconsistent throughout."],
+            ["An extraordinary achievement in filmmaking — the direction was masterful, the script was sharp, and every performance added depth and realism."],
+            ["Despite a promising start, the film quickly devolved into a series of clichés, with weak character development and an ending that felt rushed and unearned."],
+            ["A beautifully crafted story with heartfelt moments and a soundtrack that perfectly captured the emotional tone of each scene."],
+            ["The movie was far too long, with unnecessary subplots and dull dialogue that made it difficult to stay engaged until the end."]
         ]
+
     
-    @handle_errors(default_return=("Please enter text", None, None, None))
-    def analyze_single(self, text: str, language: str, theme: str, clean_text: bool, 
-                       remove_punct: bool, remove_nums: bool):
-        """Single text analysis with enhanced visualizations"""
+    @handle_errors(default_return=("Please enter text", None, None, None, None))
+    def analyze_single(self, text: str, theme: str = 'default'):
+        """Single text analysis with key words"""
         if not text.strip():
-            return "Please enter text", None, None, None
-        
-        # Map display names to language codes
-        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
-        language_code = language_map.get(language, 'auto')
-        
-        preprocessing_options = {
-            'clean_text': clean_text,
-            'remove_punctuation': remove_punct,
-            'remove_numbers': remove_nums
-        }
-        
-        with memory_cleanup():
-            result = self.engine.analyze_single(text, language_code, preprocessing_options)
-            
-            # Add to history
-            history_entry = {
-                'text': text[:100] + '...' if len(text) > 100 else text,
-                'full_text': text,
-                'sentiment': result['sentiment'],
-                'confidence': result['confidence'],
-                'pos_prob': result.get('pos_prob', 0),
-                'neg_prob': result.get('neg_prob', 0),
-                'neu_prob': result.get('neu_prob', 0),
-                'language': result['language'],
-                'keywords': result['keywords'],
-                'word_count': result['word_count'],
-                'analysis_type': 'single'
-            }
-            self.history.add(history_entry)
-            
-            # Create visualizations
-            theme_ctx = ThemeContext(theme)
-            gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme_ctx)
-            bars_fig = PlotlyVisualizer.create_probability_bars(result, theme_ctx)
-            keyword_fig = PlotlyVisualizer.create_keyword_chart(result['keywords'], result['sentiment'], theme_ctx)
-            
-            # Create comprehensive result text
-            keywords_str = ", ".join([f"{word}({score:.3f})" for word, score in result['keywords'][:5]])
-            
-            info_text = f"""
-**Analysis Results:**
-- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
-- **Language:** {result['language'].upper()}
-- **Keywords:** {keywords_str}
-- **Statistics:** {result['word_count']} words, {result['char_count']} characters
-            """
-            
-            return info_text, gauge_fig, bars_fig, keyword_fig
-    
-    @handle_errors(default_return=("Please enter texts", None, None, None))
-    def analyze_batch(self, batch_text: str, language: str, theme: str, 
-                     clean_text: bool, remove_punct: bool, remove_nums: bool):
-        """Enhanced batch analysis"""
-        if not batch_text.strip():
-            return "Please enter texts (one per line)", None, None, None
-        
-        # Parse batch input
-        texts = TextProcessor.parse_batch_input(batch_text)
+            return "Please enter text", None, None, None, None
         
-        if len(texts) > config.BATCH_SIZE_LIMIT:
-            return f"Too many texts. Maximum {config.BATCH_SIZE_LIMIT} allowed.", None, None, None
-        
-        if not texts:
-            return "No valid texts found", None, None, None
-        
-        # Map display names to language codes
-        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
-        language_code = language_map.get(language, 'auto')
-        
-        preprocessing_options = {
-            'clean_text': clean_text,
-            'remove_punctuation': remove_punct,
-            'remove_numbers': remove_nums
-        }
+        result = self.engine.analyze_single(text)
         
-        with memory_cleanup():
-            results = self.engine.analyze_batch(texts, language_code, preprocessing_options)
-            
-            # Add to history
-            batch_entries = []
-            for result in results:
-                if 'error' not in result:
-                    entry = {
-                        'text': result['text'],
-                        'full_text': result['full_text'],
-                        'sentiment': result['sentiment'],
-                        'confidence': result['confidence'],
-                        'pos_prob': result.get('pos_prob', 0),
-                        'neg_prob': result.get('neg_prob', 0),
-                        'neu_prob': result.get('neu_prob', 0),
-                        'language': result['language'],
-                        'keywords': result['keywords'],
-                        'word_count': result['word_count'],
-                        'analysis_type': 'batch',
-                        'batch_index': result['batch_index']
-                    }
-                    batch_entries.append(entry)
-            
-            self.history.add_batch(batch_entries)
-            
-            # Create visualizations
-            theme_ctx = ThemeContext(theme)
-            summary_fig = PlotlyVisualizer.create_batch_summary(results, theme_ctx)
-            confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
-            
-            # Create results DataFrame
-            df_data = []
-            for result in results:
-                if 'error' in result:
-                    df_data.append({
-                        'Index': result['batch_index'] + 1,
-                        'Text': result['text'],
-                        'Sentiment': 'Error',
-                        'Confidence': 0.0,
-                        'Language': 'Unknown',
-                        'Error': result['error']
-                    })
-                else:
-                    keywords_str = ', '.join([word for word, _ in result['keywords'][:3]])
-                    df_data.append({
-                        'Index': result['batch_index'] + 1,
-                        'Text': result['text'],
-                        'Sentiment': result['sentiment'],
-                        'Confidence': f"{result['confidence']:.3f}",
-                        'Language': result['language'].upper(),
-                        'Keywords': keywords_str
-                    })
-            
-            df = pd.DataFrame(df_data)
-            
-            # Create summary text
-            successful_results = [r for r in results if 'error' not in r]
-            error_count = len(results) - len(successful_results)
-            
-            if successful_results:
-                sentiment_counts = Counter([r['sentiment'] for r in successful_results])
-                avg_confidence = np.mean([r['confidence'] for r in successful_results])
-                languages = Counter([r['language'] for r in successful_results])
-                
-                summary_text = f"""
-**Batch Analysis Summary:**
-- **Total Texts:** {len(texts)}
-- **Successful:** {len(successful_results)}
-- **Errors:** {error_count}
-- **Average Confidence:** {avg_confidence:.3f}
-- **Sentiments:** {dict(sentiment_counts)}
-- **Languages Detected:** {dict(languages)}
-                """
-            else:
-                summary_text = f"All {len(texts)} texts failed to analyze."
-            
-            return summary_text, df, summary_fig, confidence_fig
-    
-    @handle_errors(default_return=(None, "No history available"))
-    def plot_history(self, theme: str = 'default'):
-        """Plot comprehensive history analysis"""
-        history = self.history.get_all()
-        if len(history) < 2:
-            return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
+        # Add to history
+        self.history.add({
+            'text': text[:100],
+            'full_text': text,
+            **result
+        })
         
+        # Create visualizations
         theme_ctx = ThemeContext(theme)
+        probs = np.array([result['neg_prob'], result['pos_prob']])
         
-        with memory_cleanup():
-            fig = PlotlyVisualizer.create_history_dashboard(history, theme_ctx)
-            stats = self.history.get_stats()
-            
-            stats_text = f"""
-**History Statistics:**
-- **Total Analyses:** {stats.get('total_analyses', 0)}
-- **Positive:** {stats.get('positive_count', 0)}
-- **Negative:** {stats.get('negative_count', 0)}
-- **Neutral:** {stats.get('neutral_count', 0)}
-- **Average Confidence:** {stats.get('avg_confidence', 0):.3f}
-- **Languages:** {stats.get('languages_detected', 0)}
-- **Most Common Language:** {stats.get('most_common_language', 'N/A').upper()}
-            """
-            
-            return fig, stats_text
-    
-    @handle_errors(default_return=("No data available",))
-    def get_history_status(self):
-        """Get current history status"""
-        stats = self.history.get_stats()
-        if not stats:
-            return "No analyses performed yet"
-        
-        return f"""
-**Current Status:**
-- **Total Analyses:** {stats['total_analyses']}
-- **Recent Sentiment Distribution:** 
-  * Positive: {stats['positive_count']}
-  * Negative: {stats['negative_count']}  
-  * Neutral: {stats['neutral_count']}
-- **Average Confidence:** {stats['avg_confidence']:.3f}
-- **Languages Detected:** {stats['languages_detected']}
-        """
-
-# Gradio Interface
-def create_interface():
-    """Create comprehensive Gradio interface"""
-    app = SentimentApp()
-    
-    with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
-        gr.Markdown("# 🌍 Advanced Multilingual Sentiment Analyzer")
-        gr.Markdown("AI-powered sentiment analysis with support for multiple languages, advanced visualizations, and explainable AI features")
-        
-        with gr.Tab("Single Analysis"):
-            with gr.Row():
-                with gr.Column():
-                    text_input = gr.Textbox(
-                        label="Enter Text for Analysis",
-                        placeholder="Enter your text in any supported language...",
-                        lines=5
-                    )
-                    
-                    with gr.Row():
-                        language_selector = gr.Dropdown(
-                            choices=list(config.SUPPORTED_LANGUAGES.values()),
-                            value="Auto Detect",
-                            label="Language"
-                        )
-                        theme_selector = gr.Dropdown(
-                            choices=list(config.THEMES.keys()),
-                            value="default",
-                            label="Theme"
-                        )
-                    
-                    with gr.Row():
-                        clean_text_cb = gr.Checkbox(label="Clean Text", value=False)
-                        remove_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
-                        remove_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
-                    
-                    analyze_btn = gr.Button("Analyze", variant="primary", size="lg")
-                    
-                    gr.Examples(
-                        examples=app.examples,
-                        inputs=text_input,
-                        cache_examples=False
-                    )
-                
-                with gr.Column():
-                    result_output = gr.Textbox(label="Analysis Results", lines=8)
-            
-            with gr.Row():
-                gauge_plot = gr.Plot(label="Sentiment Gauge")
-                probability_plot = gr.Plot(label="Probability Distribution")
-            
-            with gr.Row():
-                keyword_plot = gr.Plot(label="Key Contributing Words")
-        
-        with gr.Tab("Batch Analysis"):
-            with gr.Row():
-                with gr.Column():
-                    file_upload = gr.File(
-                        label="Upload File (CSV/TXT)", 
-                        file_types=[".csv", ".txt"]
-                    )
-                    batch_input = gr.Textbox(
-                        label="Batch Input (one text per line)",
-                        placeholder="Enter multiple texts, one per line...",
-                        lines=10
-                    )
-                    
-                    with gr.Row():
-                        batch_language = gr.Dropdown(
-                            choices=list(config.SUPPORTED_LANGUAGES.values()),
-                            value="Auto Detect",
-                            label="Language"
-                        )
-                        batch_theme = gr.Dropdown(
-                            choices=list(config.THEMES.keys()),
-                            value="default",
-                            label="Theme"
-                        )
-                    
-                    with gr.Row():
-                        batch_clean_cb = gr.Checkbox(label="Clean Text", value=False)
-                        batch_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
-                        batch_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
-                    
-                    with gr.Row():
-                        load_file_btn = gr.Button("Load File")
-                        analyze_batch_btn = gr.Button("Analyze Batch", variant="primary")
-                
-                with gr.Column():
-                    batch_summary = gr.Textbox(label="Batch Summary", lines=8)
-                    batch_results_df = gr.Dataframe(
-                        label="Detailed Results",
-                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Keywords"],
-                        datatype=["number", "str", "str", "str", "str", "str"]
-                    )
-            
-            with gr.Row():
-                batch_plot = gr.Plot(label="Batch Analysis Summary")
-                confidence_dist_plot = gr.Plot(label="Confidence Distribution")
+        prob_plot = PlotFactory.create_sentiment_bars(probs, theme_ctx)
+        gauge_plot = PlotFactory.create_confidence_gauge(result['confidence'], result['sentiment'], theme_ctx)
+        cloud_plot = PlotFactory.create_wordcloud(text, result['sentiment'], theme_ctx)
+        keyword_plot = PlotFactory.create_keyword_chart(result['key_words'], result['sentiment'], theme_ctx)
         
-        with gr.Tab("History & Analytics"):
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        refresh_history_btn = gr.Button("Refresh History")
-                        clear_history_btn = gr.Button("Clear History", variant="stop")
-                        status_btn = gr.Button("Get Status")
-                    
-                    history_theme = gr.Dropdown(
-                        choices=list(config.THEMES.keys()),
-                        value="default",
-                        label="Dashboard Theme"
-                    )
-                    
-                    with gr.Row():
-                        export_csv_btn = gr.Button("Export CSV")
-                        export_json_btn = gr.Button("Export JSON")
-                
-                with gr.Column():
-                    history_status = gr.Textbox(label="History Status", lines=8)
-            
-            history_dashboard = gr.Plot(label="History Analytics Dashboard")
-            
-            with gr.Row():
-                csv_download = gr.File(label="CSV Download", visible=True)
-                json_download = gr.File(label="JSON Download", visible=True)
-        
-        # Event Handlers
-        analyze_btn.click(
-            app.analyze_single,
-            inputs=[text_input, language_selector, theme_selector, 
-                   clean_text_cb, remove_punct_cb, remove_nums_cb],
-            outputs=[result_output, gauge_plot, probability_plot, keyword_plot]
-        )
-        
-        load_file_btn.click(
-            app.data_handler.process_file,
-            inputs=file_upload,
-            outputs=batch_input
-        )
-        
-        analyze_batch_btn.click(
-            app.analyze_batch,
-            inputs=[batch_input, batch_language, batch_theme,
-                   batch_clean_cb, batch_punct_cb, batch_nums_cb],
-            outputs=[batch_summary, batch_results_df, batch_plot, confidence_dist_plot]
-        )
+        # Format result text with key words
+        key_words_str = ", ".join([f"{word}({score:.3f})" for word, score in result['key_words'][:5]])
+        result_text = (f"Sentiment: {result['sentiment']} (Confidence: {result['confidence']:.3f})\n"
+                      f"Key Words: {key_words_str}")
         
-        refresh_history_btn.click(
-            app.plot_history,
-            inputs=history_theme,
-            outputs=[history_dashboard, history_status]
-        )
-        
-        clear_history_btn.click(
-            lambda: f"Cleared {app.history.clear()} entries",
-            outputs=history_status
-        )
-        
-        status_btn.click(
-            app.get_history_status,
-            outputs=history_status
-        )
-        
-        export_csv_btn.click(
-            lambda: app.data_handler.export_data(app.history.get_all(), 'csv'),
-            outputs=[csv_download, history_status]
-        )
-        
-        export_json_btn.click(
-            lambda: app.data_handler.export_data(app.history.get_all(), 'json'),
-            outputs=[json_download, history_status]
-        )
-    
-    return demo
-
-# Application Entry Point
-if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+        return result_text, prob_plot, gauge_plot, cloud_plot, keyword_plot
     
-    try:
-        demo = create_interface()
-        demo.launch(
-            share=True,
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True
-        )
-    except Exception as e:
-        logger.error(f"Failed to launch application: {e}")
-        raise
-    
-    @handle_errors(default_return=("Please enter texts", None, None, None))
-    def analyze_batch(self, batch_text: str, language: str, theme: str, 
-                     clean_text: bool, remove_punct: bool, remove_nums: bool):
-        """Enhanced batch analysis"""
-        if not batch_text.strip():
-            return "Please enter texts (one per line)", None, None, None
-        
-        # Parse batch input
-        texts = TextProcessor.parse_batch_input(batch_text)
-        
-        if len(texts) > config.BATCH_SIZE_LIMIT:
-            return f"Too many texts. Maximum {config.BATCH_SIZE_LIMIT} allowed.", None, None, None
+    @handle_errors(default_return=None)
+    def analyze_batch(self, reviews: str, progress=None):
+        """Batch analysis"""
+        if not reviews.strip():
+            return None
         
-        if not texts:
-            return "No valid texts found", None, None, None
+        texts = [r.strip() for r in reviews.split('\n') if r.strip()]
+        if len(texts) < 2:
+            return None
         
-        # Map display names to language codes
-        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
-        language_code = language_map.get(language, 'auto')
+        results = self.engine.analyze_batch(texts, progress)
         
-        preprocessing_options = {
-            'clean_text': clean_text,
-            'remove_punctuation': remove_punct,
-            'remove_numbers': remove_nums
-        }
+        # Add to history
+        for result in results:
+            self.history.add(result)
         
-        with memory_cleanup():
-            results = self.engine.analyze_batch(texts, language_code, preprocessing_options)
-            
-            # Add to history
-            batch_entries = []
-            for result in results:
-                if 'error' not in result:
-                    entry = {
-                        'text': result['text'],
-                        'full_text': result['full_text'],
-                        'sentiment': result['sentiment'],
-                        'confidence': result['confidence'],
-                        'pos_prob': result.get('pos_prob', 0),
-                        'neg_prob': result.get('neg_prob', 0),
-                        'neu_prob': result.get('neu_prob', 0),
-                        'language': result['language'],
-                        'keywords': result['keywords'],
-                        'word_count': result['word_count'],
-                        'analysis_type': 'batch',
-                        'batch_index': result['batch_index']
-                    }
-                    batch_entries.append(entry)
-            
-            self.history.add_batch(batch_entries)
-            
-            # Create visualizations
-            theme_ctx = ThemeContext(theme)
-            summary_fig = PlotlyVisualizer.create_batch_summary(results, theme_ctx)
-            confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
-            
-            # Create results DataFrame
-            df_data = []
-            for result in results:
-                if 'error' in result:
-                    df_data.append({
-                        'Index': result['batch_index'] + 1,
-                        'Text': result['text'],
-                        'Sentiment': 'Error',
-                        'Confidence': 0.0,
-                        'Language': 'Unknown',
-                        'Error': result['error']
-                    })
-                else:
-                    keywords_str = ', '.join([word for word, _ in result['keywords'][:3]])
-                    df_data.append({
-                        'Index': result['batch_index'] + 1,
-                        'Text': result['text'],
-                        'Sentiment': result['sentiment'],
-                        'Confidence': f"{result['confidence']:.3f}",
-                        'Language': result['language'].upper(),
-                        'Keywords': keywords_str
-                    })
-            
-            df = pd.DataFrame(df_data)
-            
-            # Create summary text
-            successful_results = [r for r in results if 'error' not in r]
-            error_count = len(results) - len(successful_results)
-            
-            if successful_results:
-                sentiment_counts = Counter([r['sentiment'] for r in successful_results])
-                avg_confidence = np.mean([r['confidence'] for r in successful_results])
-                languages = Counter([r['language'] for r in successful_results])
-                
-                summary_text = f"""
-**Batch Analysis Summary:**
-- **Total Texts:** {len(texts)}
-- **Successful:** {len(successful_results)}
-- **Errors:** {error_count}
-- **Average Confidence:** {avg_confidence:.3f}
-- **Sentiments:** {dict(sentiment_counts)}
-- **Languages Detected:** {dict(languages)}
-                """
-            else:
-                summary_text = f"All {len(texts)} texts failed to analyze."
-            
-            return summary_text, df, summary_fig, confidence_fig
+        # Create visualization
+        theme_ctx = ThemeContext('default')
+        return PlotFactory.create_batch_analysis(results, theme_ctx)
     
     @handle_errors(default_return=(None, "No history available"))
     def plot_history(self, theme: str = 'default'):
-        """Plot comprehensive history analysis"""
+        """Plot analysis history"""
         history = self.history.get_all()
         if len(history) < 2:
             return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
         
         theme_ctx = ThemeContext(theme)
         
-        with memory_cleanup():
-            fig = PlotlyVisualizer.create_history_dashboard(history, theme_ctx)
-            stats = self.history.get_stats()
-            
-            stats_text = f"""
-**History Statistics:**
-- **Total Analyses:** {stats.get('total_analyses', 0)}
-- **Positive:** {stats.get('positive_count', 0)}
-- **Negative:** {stats.get('negative_count', 0)}
-- **Neutral:** {stats.get('neutral_count', 0)}
-- **Average Confidence:** {stats.get('avg_confidence', 0):.3f}
-- **Languages:** {stats.get('languages_detected', 0)}
-- **Most Common Language:** {stats.get('most_common_language', 'N/A').upper()}
-            """
-            
-            return fig, stats_text
-    
-    @handle_errors(default_return=("No data available",))
-    def get_history_status(self):
-        """Get current history status"""
-        stats = self.history.get_stats()
-        if not stats:
-            return "No analyses performed yet"
-        
-        return f"""
-**Current Status:**
-- **Total Analyses:** {stats['total_analyses']}
-- **Recent Sentiment Distribution:** 
-  * Positive: {stats['positive_count']}
-  * Negative: {stats['negative_count']}  
-  * Neutral: {stats['neutral_count']}
-- **Average Confidence:** {stats['avg_confidence']:.3f}
-- **Languages Detected:** {stats['languages_detected']}
-        """
+        with managed_figure(figsize=(12, 8)) as fig:
+            gs = fig.add_gridspec(2, 1, hspace=0.3)
+            
+            indices = list(range(len(history)))
+            pos_probs = [item['pos_prob'] for item in history]
+            confs = [item['confidence'] for item in history]
+            
+            # Sentiment trend
+            ax1 = fig.add_subplot(gs[0, 0])
+            colors = [theme_ctx.colors['pos'] if p > 0.5 else theme_ctx.colors['neg'] 
+                     for p in pos_probs]
+            ax1.scatter(indices, pos_probs, c=colors, alpha=0.7, s=60)
+            ax1.plot(indices, pos_probs, alpha=0.5, linewidth=2)
+            ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+            ax1.set_title('Sentiment History')
+            ax1.set_ylabel('Positive Probability')
+            ax1.grid(True, alpha=0.3)
+            
+            # Confidence trend
+            ax2 = fig.add_subplot(gs[1, 0])
+            ax2.bar(indices, confs, alpha=0.7, color='lightblue', edgecolor='navy')
+            ax2.set_title('Confidence Over Time')
+            ax2.set_xlabel('Analysis Number')
+            ax2.set_ylabel('Confidence')
+            ax2.grid(True, alpha=0.3)
+            
+            fig.tight_layout()
+            return fig, f"History: {len(history)} analyses"
 
-# Gradio Interface
+# Gradio Interface Setup
 def create_interface():
-    """Create comprehensive Gradio interface"""
+    """Create streamlined Gradio interface"""
     app = SentimentApp()
     
-    with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
-        gr.Markdown("# 🌍 Advanced Multilingual Sentiment Analyzer")
-        gr.Markdown("AI-powered sentiment analysis with support for multiple languages, advanced visualizations, and explainable AI features")
+    with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as demo:
+        gr.Markdown("# 🎬 AI Movie Sentiment Analyzer")
+        gr.Markdown("Optimized sentiment analysis with advanced visualizations and key word extraction")
         
         with gr.Tab("Single Analysis"):
             with gr.Row():
                 with gr.Column():
                     text_input = gr.Textbox(
-                        label="Enter Text for Analysis",
-                        placeholder="Enter your text in any supported language...",
+                        label="Movie Review",
+                        placeholder="Enter your movie review...",
                         lines=5
                     )
-                    
                     with gr.Row():
-                        language_selector = gr.Dropdown(
-                            choices=list(config.SUPPORTED_LANGUAGES.values()),
-                            value="Auto Detect",
-                            label="Language"
-                        )
+                        analyze_btn = gr.Button("Analyze", variant="primary")
                         theme_selector = gr.Dropdown(
                             choices=list(config.THEMES.keys()),
                             value="default",
                             label="Theme"
                         )
                     
-                    with gr.Row():
-                        clean_text_cb = gr.Checkbox(label="Clean Text", value=False)
-                        remove_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
-                        remove_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
-                    
-                    analyze_btn = gr.Button("Analyze", variant="primary", size="lg")
-                    
                     gr.Examples(
                         examples=app.examples,
-                        inputs=text_input,
-                        cache_examples=False
+                        inputs=text_input
                     )
                 
                 with gr.Column():
-                    result_output = gr.Textbox(label="Analysis Results", lines=8)
+                    result_output = gr.Textbox(label="Result", lines=3)
             
             with gr.Row():
-                gauge_plot = gr.Plot(label="Sentiment Gauge")
-                probability_plot = gr.Plot(label="Probability Distribution")
+                prob_plot = gr.Plot(label="Probabilities")
+                gauge_plot = gr.Plot(label="Confidence")
             
             with gr.Row():
+                wordcloud_plot = gr.Plot(label="Word Cloud")
                 keyword_plot = gr.Plot(label="Key Contributing Words")
         
         with gr.Tab("Batch Analysis"):
             with gr.Row():
                 with gr.Column():
-                    file_upload = gr.File(
-                        label="Upload File (CSV/TXT)", 
-                        file_types=[".csv", ".txt"]
-                    )
+                    file_upload = gr.File(label="Upload File", file_types=[".csv", ".txt"])
                     batch_input = gr.Textbox(
-                        label="Batch Input (one text per line)",
-                        placeholder="Enter multiple texts, one per line...",
-                        lines=10
+                        label="Reviews (one per line)",
+                        lines=8
                     )
-                    
-                    with gr.Row():
-                        batch_language = gr.Dropdown(
-                            choices=list(config.SUPPORTED_LANGUAGES.values()),
-                            value="Auto Detect",
-                            label="Language"
-                        )
-                        batch_theme = gr.Dropdown(
-                            choices=list(config.THEMES.keys()),
-                            value="default",
-                            label="Theme"
-                        )
-                    
-                    with gr.Row():
-                        batch_clean_cb = gr.Checkbox(label="Clean Text", value=False)
-                        batch_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
-                        batch_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
-                    
-                    with gr.Row():
-                        load_file_btn = gr.Button("Load File")
-                        analyze_batch_btn = gr.Button("Analyze Batch", variant="primary")
                 
                 with gr.Column():
-                    batch_summary = gr.Textbox(label="Batch Summary", lines=8)
-                    batch_results_df = gr.Dataframe(
-                        label="Detailed Results",
-                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Keywords"],
-                        datatype=["number", "str", "str", "str", "str", "str"]
-                    )
+                    load_btn = gr.Button("Load File")
+                    batch_btn = gr.Button("Analyze Batch", variant="primary")
             
-            with gr.Row():
-                batch_plot = gr.Plot(label="Batch Analysis Summary")
-                confidence_dist_plot = gr.Plot(label="Confidence Distribution")
+            batch_plot = gr.Plot(label="Batch Results")
         
-        with gr.Tab("History & Analytics"):
+        with gr.Tab("History & Export"):
             with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        refresh_history_btn = gr.Button("Refresh History")
-                        clear_history_btn = gr.Button("Clear History", variant="stop")
-                        status_btn = gr.Button("Get Status")
-                    
-                    history_theme = gr.Dropdown(
-                        choices=list(config.THEMES.keys()),
-                        value="default",
-                        label="Dashboard Theme"
-                    )
-                    
-                    with gr.Row():
-                        export_csv_btn = gr.Button("Export CSV")
-                        export_json_btn = gr.Button("Export JSON")
-                
-                with gr.Column():
-                    history_status = gr.Textbox(label="History Status", lines=8)
-            
-            history_dashboard = gr.Plot(label="History Analytics Dashboard")
+                refresh_btn = gr.Button("Refresh")
+                clear_btn = gr.Button("Clear", variant="stop")
+                status_btn = gr.Button("Status")
             
             with gr.Row():
-                csv_download = gr.File(label="CSV Download", visible=True)
-                json_download = gr.File(label="JSON Download", visible=True)
+                csv_btn = gr.Button("Export CSV")
+                json_btn = gr.Button("Export JSON")
+            
+            history_status = gr.Textbox(label="Status")
+            history_plot = gr.Plot(label="History Trends")
+            csv_file = gr.File(label="CSV Download", visible=True)
+            json_file = gr.File(label="JSON Download", visible=True)
         
-        # Event Handlers
+        # Event bindings
         analyze_btn.click(
             app.analyze_single,
-            inputs=[text_input, language_selector, theme_selector, 
-                   clean_text_cb, remove_punct_cb, remove_nums_cb],
-            outputs=[result_output, gauge_plot, probability_plot, keyword_plot]
+            inputs=[text_input, theme_selector],
+            outputs=[result_output, prob_plot, gauge_plot, wordcloud_plot, keyword_plot]
         )
         
-        load_file_btn.click(
-            app.data_handler.process_file,
-            inputs=file_upload,
-            outputs=batch_input
-        )
+        load_btn.click(app.data_handler.process_file, inputs=file_upload, outputs=batch_input)
+        batch_btn.click(app.analyze_batch, inputs=batch_input, outputs=batch_plot)
         
-        analyze_batch_btn.click(
-            app.analyze_batch,
-            inputs=[batch_input, batch_language, batch_theme,
-                   batch_clean_cb, batch_punct_cb, batch_nums_cb],
-            outputs=[batch_summary, batch_results_df, batch_plot, confidence_dist_plot]
+        refresh_btn.click(
+            lambda theme: app.plot_history(theme),
+            inputs=theme_selector,
+            outputs=[history_plot, history_status]
         )
         
-        refresh_history_btn.click(
-            app.plot_history,
-            inputs=history_theme,
-            outputs=[history_dashboard, history_status]
-        )
-        
-        clear_history_btn.click(
+        clear_btn.click(
             lambda: f"Cleared {app.history.clear()} entries",
             outputs=history_status
         )
         
         status_btn.click(
-            app.get_history_status,
+            lambda: f"History: {app.history.size()} entries",
             outputs=history_status
         )
         
-        export_csv_btn.click(
+        csv_btn.click(
             lambda: app.data_handler.export_data(app.history.get_all(), 'csv'),
-            outputs=[csv_download, history_status]
+            outputs=[csv_file, history_status]
         )
         
-        export_json_btn.click(
+        json_btn.click(
             lambda: app.data_handler.export_data(app.history.get_all(), 'json'),
-            outputs=[json_download, history_status]
+            outputs=[json_file, history_status]
         )
     
     return demo
 
 # Application Entry Point
 if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-    
-    try:
-        demo = create_interface()
-        demo.launch(
-            share=True,
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True
-        )
-    except Exception as e:
-        logger.error(f"Failed to launch application: {e}")
-        raise
+    logging.basicConfig(level=logging.INFO)
+    demo = create_interface()
+    demo.launch(share=True)