Update app.py

app.py

@@ -5,6 +5,7 @@ import plotly.graph_objects as go
 import plotly.express as px
 from plotly.subplots import make_subplots
 import numpy as np
+from wordcloud import WordCloud
 from collections import Counter, defaultdict
 import re
 import json
@@ -16,54 +17,11 @@ import logging
 from functools import lru_cache
 from dataclasses import dataclass
 from typing import List, Dict, Optional, Tuple
+import nltk
+from nltk.corpus import stopwords
+import langdetect
 import pandas as pd
 
-# 设置日志 - 提前初始化
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# 尝试导入可选依赖
-try:
-    from wordcloud import WordCloud
-    WORDCLOUD_AVAILABLE = True
-except ImportError:
-    WORDCLOUD_AVAILABLE = False
-    logger.warning("WordCloud not available")
-
-try:
-    import nltk
-    from nltk.corpus import stopwords
-    nltk.download('stopwords', quiet=True)
-    nltk.download('punkt', quiet=True)
-    STOP_WORDS = set(stopwords.words('english'))
-    NLTK_AVAILABLE = True
-except:
-    NLTK_AVAILABLE = False
-    STOP_WORDS = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
-    logger.warning("NLTK not available, using basic stopwords")
-
-try:
-    import langdetect
-    LANGDETECT_AVAILABLE = True
-except ImportError:
-    LANGDETECT_AVAILABLE = False
-    logger.warning("langdetect not available, using fallback language detection")
-
-# 尝试导入SHAP和LIME
-try:
-    import shap
-    SHAP_AVAILABLE = True
-except ImportError:
-    SHAP_AVAILABLE = False
-    logger.warning("SHAP not available, using basic analysis")
-
-try:
-    from lime.lime_text import LimeTextExplainer
-    LIME_AVAILABLE = True
-except ImportError:
-    LIME_AVAILABLE = False
-    logger.warning("LIME not available, using basic analysis")
-
 # Configuration
 @dataclass
 class Config:
@@ -83,13 +41,10 @@ class Config:
         'sv': 'Swedish'
     }
     
-    # 使用更稳定的模型
     MODELS = {
         'en': "cardiffnlp/twitter-roberta-base-sentiment-latest",
         'multilingual': "cardiffnlp/twitter-xlm-roberta-base-sentiment",
-        'zh': "uer/roberta-base-finetuned-dianping-chinese",
-        # 备用模型
-        'fallback': "distilbert-base-uncased-finetuned-sst-2-english"
+        'zh': "uer/roberta-base-finetuned-dianping-chinese"
     }
     
     # Color themes
@@ -102,80 +57,62 @@ class Config:
 
 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'}
+
 class ModelManager:
-    """Manages multiple language models with better error handling"""
+    """Manages multiple language models"""
     def __init__(self):
         self.models = {}
         self.tokenizers = {}
-        self.device = self._get_device()
-        self.model_loaded = False
-        self._load_models()
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self._load_default_model()
     
-    def _get_device(self):
-        """安全的设备选择"""
+    def _load_default_model(self):
+        """Load the default models"""
         try:
-            if torch.cuda.is_available():
-                return torch.device("cuda")
-            elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-                return torch.device("mps")
-            else:
-                return torch.device("cpu")
-        except:
-            return torch.device("cpu")
-    
-    def _load_models(self):
-        """Load models with error handling"""
-        try:
-            # 首先尝试加载多语言模型
+            # Load multilingual model as default
             model_name = config.MODELS['multilingual']
-            logger.info(f"Loading model: {model_name}")
-            
             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}")
             
-            logger.info(f"Successfully loaded default model: {model_name}")
-            self.model_loaded = True
+            # 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}")
             
         except Exception as e:
-            logger.error(f"Failed to load multilingual model: {e}")
-            # 尝试备用模型
-            try:
-                fallback_model = config.MODELS['fallback']
-                logger.info(f"Trying fallback model: {fallback_model}")
-                
-                self.tokenizers['default'] = AutoTokenizer.from_pretrained(fallback_model)
-                self.models['default'] = AutoModelForSequenceClassification.from_pretrained(fallback_model)
-                self.models['default'].to(self.device)
-                
-                logger.info(f"Successfully loaded fallback model: {fallback_model}")
-                self.model_loaded = True
-                
-            except Exception as e2:
-                logger.error(f"Failed to load fallback model: {e2}")
-                self.model_loaded = False
-                raise RuntimeError("Failed to load any sentiment analysis model")
+            logger.error(f"Failed to load models: {e}")
+            raise
     
     def get_model(self, language='en'):
         """Get model for specific language"""
-        if not self.model_loaded:
-            raise RuntimeError("No models are loaded")
-        
-        # 简化：所有语言都使用默认模型
-        return self.models['default'], self.tokenizers['default']
+        if language == 'zh':
+            return self.models['zh'], self.tokenizers['zh']
+        elif language in ['en', 'auto'] or language not in config.SUPPORTED_LANGUAGES:
+            return self.models['default'], self.tokenizers['default']
+        return self.models['default'], self.tokenizers['default']  # Use multilingual for other languages
     
     @staticmethod
     def detect_language(text: str) -> str:
-        """Detect text language with fallback"""
-        if not LANGDETECT_AVAILABLE:
-            # 简单的语言检测
-            if re.search(r'[\u4e00-\u9fff]', text):
-                return 'zh'
-            else:
-                return 'en'
-        
+        """Detect text language properly"""
         try:
+            # Use langdetect for all languages
             detected = langdetect.detect(text)
+            # Map some common langdetect codes to our supported languages
             language_mapping = {
                 'zh-cn': 'zh',
                 'zh-tw': 'zh'
@@ -185,23 +122,10 @@ class ModelManager:
         except:
             return 'en'
 
-# 全局模型管理器
-model_manager = None
-
-def initialize_models():
-    """延迟初始化模型"""
-    global model_manager
-    if model_manager is None:
-        try:
-            model_manager = ModelManager()
-            return True
-        except Exception as e:
-            logger.error(f"Model initialization failed: {e}")
-            return False
-    return True
+model_manager = ModelManager()
 
 class HistoryManager:
-    """Enhanced history manager"""
+    """Enhanced history manager with more features"""
     def __init__(self):
         self._history = []
     
@@ -211,6 +135,7 @@ class HistoryManager:
             self._history = self._history[-config.MAX_HISTORY_SIZE:]
     
     def add_batch_entries(self, entries: List[Dict]):
+        """Add multiple entries at once"""
         for entry in entries:
             self.add_entry(entry)
     
@@ -218,10 +143,12 @@ class HistoryManager:
         return self._history.copy()
     
     def get_recent_history(self, n: int = 10) -> List[Dict]:
+        """Get n most recent entries"""
         return self._history[-n:] if self._history else []
     
     def filter_history(self, sentiment: str = None, language: str = None, 
                       min_confidence: float = None) -> List[Dict]:
+        """Filter history by criteria"""
         filtered = self._history
         
         if sentiment:
@@ -251,12 +178,12 @@ class HistoryManager:
             'positive_count': sentiments.count('Positive'),
             'negative_count': sentiments.count('Negative'),
             'neutral_count': sentiments.count('Neutral'),
-            'avg_confidence': np.mean(confidences) if confidences else 0,
-            'max_confidence': np.max(confidences) if confidences else 0,
-            'min_confidence': np.min(confidences) if confidences else 0,
+            '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',
-            'avg_text_length': np.mean([len(item.get('full_text', '')) for item in self._history]) if self._history else 0
+            'avg_text_length': np.mean([len(item.get('full_text', '')) for item in self._history])
         }
 
 history_manager = HistoryManager()
@@ -283,12 +210,14 @@ class TextProcessor:
     @staticmethod
     def extract_keywords(text: str, top_k: int = 5) -> List[str]:
         """Extract key words from text"""
+        # For Chinese text, extract characters
         if re.search(r'[\u4e00-\u9fff]', text):
             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:
+            # For other languages, use word-based extraction
             cleaned = TextProcessor.clean_text(text)
             words = cleaned.split()
             word_freq = Counter(words)
@@ -301,7 +230,7 @@ class TextProcessor:
         return [line.strip() for line in lines if line.strip()]
 
 class SentimentAnalyzer:
-    """Enhanced sentiment analysis with better error handling"""
+    """Enhanced sentiment analysis"""
     
     @staticmethod
     def analyze_text(text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
@@ -309,10 +238,6 @@ class SentimentAnalyzer:
         if not text.strip():
             raise ValueError("Empty text provided")
         
-        # 确保模型已加载
-        if not initialize_models():
-            raise RuntimeError("Failed to initialize sentiment analysis models")
-        
         # Detect language if auto
         if language == 'auto':
             detected_lang = model_manager.detect_language(text)
@@ -320,13 +245,9 @@ class SentimentAnalyzer:
             detected_lang = language
         
         # Get appropriate model
-        try:
-            model, tokenizer = model_manager.get_model(detected_lang)
-        except Exception as e:
-            logger.error(f"Failed to get model: {e}")
-            raise RuntimeError(f"Model loading failed: {e}")
+        model, tokenizer = model_manager.get_model(detected_lang)
         
-        # Preprocessing
+        # Preprocessing options - don't clean Chinese text
         options = preprocessing_options or {}
         processed_text = text
         if options.get('clean_text', False) and not re.search(r'[\u4e00-\u9fff]', text):
@@ -338,13 +259,8 @@ class SentimentAnalyzer:
         
         try:
             # Tokenize and analyze
-            inputs = tokenizer(
-                processed_text, 
-                return_tensors="pt", 
-                padding=True, 
-                truncation=True, 
-                max_length=config.MAX_TEXT_LENGTH
-            ).to(model_manager.device)
+            inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
+                             truncation=True, max_length=config.MAX_TEXT_LENGTH).to(model_manager.device)
             
             with torch.no_grad():
                 outputs = model(**inputs)
@@ -391,7 +307,7 @@ class SentimentAnalyzer:
             
         except Exception as e:
             logger.error(f"Analysis failed: {e}")
-            raise RuntimeError(f"Sentiment analysis failed: {e}")
+            raise
 
     @staticmethod
     def analyze_batch(texts: List[str], language: str = 'auto', 
@@ -404,461 +320,207 @@ class SentimentAnalyzer:
                 result['batch_index'] = i
                 results.append(result)
             except Exception as e:
+                # Add error result
                 results.append({
                     'sentiment': 'Error',
                     'confidence': 0.0,
                     'error': str(e),
                     'batch_index': i,
-                    'text': text[:50] + '...' if len(text) > 50 else text
+                    'text': text
                 })
         return results
 
-class ExplainabilityAnalyzer:
-    """SHAP and LIME explainability analysis with fallbacks"""
+class PlotlyVisualizer:
+    """Enhanced visualizations with Plotly"""
     
     @staticmethod
-    def create_prediction_function(model, tokenizer, device):
-        """Create prediction function for LIME"""
-        def predict_proba(texts):
-            if isinstance(texts, str):
-                texts = [texts]
-            
-            results = []
-            for text in texts:
-                try:
-                    inputs = tokenizer(text, return_tensors="pt", padding=True, 
-                                     truncation=True, max_length=config.MAX_TEXT_LENGTH).to(device)
-                    with torch.no_grad():
-                        outputs = model(**inputs)
-                        probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
-                    results.append(probs)
-                except Exception as e:
-                    # Return neutral probabilities on error
-                    if len(results) > 0:
-                        results.append(results[0])  # Use previous result
-                    else:
-                        results.append(np.array([0.33, 0.33, 0.34]))  # Neutral fallback
-            
-            return np.array(results)
-        return predict_proba
-    
-    @staticmethod
-    def analyze_with_lime(text: str, model, tokenizer, device, num_features: int = 10) -> Dict:
-        """Analyze text with LIME"""
-        if not LIME_AVAILABLE:
-            return {'method': 'LIME', 'error': 'LIME library not available. Install with: pip install lime'}
+    def create_sentiment_gauge(result: Dict, theme: str = 'default') -> go.Figure:
+        """Create an animated sentiment gauge"""
+        colors = config.THEMES[theme]
+        
+        if result['has_neutral']:
+            # 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"}
+                    ]
+                }
+            ))
         
-        try:
-            # Create prediction function
-            predict_fn = ExplainabilityAnalyzer.create_prediction_function(model, tokenizer, device)
-            
-            # Test prediction function first
-            test_probs = predict_fn([text])
-            if len(test_probs) == 0:
-                return {'method': 'LIME', 'error': 'Prediction function failed'}
-            
-            # Determine class names based on model output
-            num_classes = len(test_probs[0])
-            if num_classes == 3:
-                class_names = ['Negative', 'Neutral', 'Positive']
-            else:
-                class_names = ['Negative', 'Positive']
-            
-            # Initialize LIME explainer
-            explainer = LimeTextExplainer(
-                class_names=class_names,
-                feature_selection='auto',
-                split_expression=r'\W+',
-                bow=False
-            )
-            
-            # Generate explanation
-            explanation = explainer.explain_instance(
-                text, 
-                predict_fn, 
-                num_features=min(num_features, len(text.split())),
-                num_samples=50  # Reduced for faster processing
-            )
-            
-            # Extract feature importance
-            feature_importance = explanation.as_list()
-            
-            return {
-                'method': 'LIME',
-                'feature_importance': feature_importance,
-                'class_names': class_names,
-                'success': True
-            }
-            
-        except Exception as e:
-            logger.error(f"LIME analysis failed: {e}")
-            return {'method': 'LIME', 'error': str(e)}
-    
-    @staticmethod
-    def analyze_with_attention(text: str, model, tokenizer, device) -> Dict:
-        """Analyze text with attention weights - simplified version"""
-        try:
-            # Tokenize input
-            inputs = tokenizer(text, return_tensors="pt", padding=True, 
-                             truncation=True, max_length=config.MAX_TEXT_LENGTH).to(device)
-            
-            # Get tokens for display
-            tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
-            
-            # Simple attention simulation based on input importance
-            try:
-                with torch.no_grad():
-                    outputs = model(**inputs, output_attentions=True)
-                    if hasattr(outputs, 'attentions') and outputs.attentions is not None:
-                        attentions = outputs.attentions
-                        # Average attention across layers and heads
-                        avg_attention = torch.mean(torch.stack(attentions), dim=(0, 1, 2)).cpu().numpy()
-                    else:
-                        raise AttributeError("No attention outputs")
-            except:
-                # Fallback: simulate attention based on token position and type
-                avg_attention = np.random.uniform(0.1, 1.0, len(tokens))
-                # Give higher attention to non-special tokens
-                for i, token in enumerate(tokens):
-                    if token in ['[CLS]', '[SEP]', '<s>', '</s>', '<pad>']:
-                        avg_attention[i] *= 0.3
-            
-            # Create attention weights for each token
-            attention_weights = []
-            for i, token in enumerate(tokens):
-                if i < len(avg_attention):
-                    # Clean token for display
-                    clean_token = token.replace('Ġ', '').replace('##', '')
-                    if clean_token.strip():
-                        attention_weights.append((clean_token, float(avg_attention[i])))
-            
-            return {
-                'method': 'Attention',
-                'tokens': [t[0] for t in attention_weights],
-                'attention_weights': attention_weights,
-                'success': True
-            }
-            
-        except Exception as e:
-            logger.error(f"Attention analysis failed: {e}")
-            return {'method': 'Attention', 'error': str(e)}
-
-class AdvancedVisualizer:
-    """Enhanced visualizations with Plotly - 修复了类名"""
+        fig.update_layout(height=400, font={'size': 16})
+        return fig
     
     @staticmethod
-    def create_lime_plot(lime_result: Dict, theme: str = 'default') -> go.Figure:
-        """Create LIME feature importance plot"""
-        if 'error' in lime_result:
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"LIME Error: {lime_result['error']}", 
-                x=0.5, y=0.5, 
-                xref="paper", yref="paper",
-                showarrow=False,
-                font=dict(size=14)
-            )
-            fig.update_layout(height=400, title="LIME Analysis Error")
-            return fig
-        
-        if not lime_result.get('feature_importance'):
-            fig = go.Figure()
-            fig.add_annotation(
-                text="No LIME features available", 
-                x=0.5, y=0.5,
-                xref="paper", yref="paper",
-                showarrow=False
-            )
-            fig.update_layout(height=400, title="No LIME Data")
-            return fig
+    def create_probability_bars(result: Dict, theme: str = 'default') -> go.Figure:
+        """Create probability bar chart"""
+        colors = config.THEMES[theme]
         
-        features, scores = zip(*lime_result['feature_importance'])
-        colors = ['red' if score < 0 else 'green' for score in scores]
+        if result['has_neutral']:
+            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(
-                y=features,
-                x=scores,
-                orientation='h',
-                marker_color=colors,
-                text=[f'{score:.3f}' for score in scores],
-                textposition='auto',
-                hovertemplate='<b>%{y}</b><br>Importance: %{x:.3f}<extra></extra>'
-            )
+            go.Bar(x=labels, y=values, marker_color=bar_colors, text=[f'{v:.3f}' for v in values])
         ])
         
+        fig.update_traces(texttemplate='%{text}', textposition='outside')
         fig.update_layout(
-            title="LIME Feature Importance Analysis",
-            xaxis_title="Importance Score (Negative ← → Positive)",
-            yaxis_title="Features",
+            title="Sentiment Probabilities",
+            yaxis_title="Probability",
             height=400,
             showlegend=False
         )
         
         return fig
-    
+
     @staticmethod
-    def create_attention_plot(attention_result: Dict, theme: str = 'default') -> go.Figure:
-        """Create attention weights visualization"""
-        if 'error' in attention_result:
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"Attention Error: {attention_result['error']}", 
-                x=0.5, y=0.5, 
-                xref="paper", yref="paper",
-                showarrow=False,
-                font=dict(size=14)
-            )
-            fig.update_layout(height=400, title="Attention Analysis Error")
-            return fig
-        
-        if not attention_result.get('attention_weights'):
-            fig = go.Figure()
-            fig.add_annotation(
-                text="No attention weights available", 
-                x=0.5, y=0.5,
-                xref="paper", yref="paper", 
-                showarrow=False
-            )
-            fig.update_layout(height=400, title="No Attention Data")
-            return fig
+    def create_batch_summary(results: List[Dict], theme: str = 'default') -> go.Figure:
+        """Create batch analysis summary"""
+        colors = config.THEMES[theme]
         
-        tokens, weights = zip(*attention_result['attention_weights'])
+        # Count sentiments
+        sentiments = [r['sentiment'] for r in results if 'sentiment' in r]
+        sentiment_counts = Counter(sentiments)
         
-        # Normalize weights for better visualization
-        weights = np.array(weights)
-        if weights.max() > weights.min():
-            normalized_weights = (weights - weights.min()) / (weights.max() - weights.min())
-        else:
-            normalized_weights = weights
+        # 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
+        )])
         
-        # Limit display to top 15 tokens for readability
-        if len(tokens) > 15:
-            # Get top 15 by attention weight
-            top_indices = np.argsort(weights)[-15:]
-            tokens = [tokens[i] for i in top_indices]
-            normalized_weights = normalized_weights[top_indices]
-            weights = weights[top_indices]
+        fig.update_layout(
+            title=f"Batch Analysis Summary ({len(results)} texts)",
+            height=400
+        )
         
-        fig = go.Figure(data=[
-            go.Bar(
-                x=list(range(len(tokens))),
-                y=normalized_weights,
-                text=tokens,
-                textposition='outside',
-                marker_color=normalized_weights,
-                colorscale='Viridis',
-                hovertemplate='<b>%{text}</b><br>Attention Weight: %{customdata:.3f}<extra></extra>',
-                customdata=weights
-            )
-        ])
+        return fig
+
+    @staticmethod
+    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="Attention Weights Analysis (Top Tokens)",
-            xaxis_title="Token Position",
-            yaxis_title="Attention Weight (Normalized)",
-            height=400,
-            showlegend=False,
-            xaxis=dict(tickmode='array', tickvals=list(range(len(tokens))), ticktext=tokens, tickangle=45)
+            title="Confidence Distribution",
+            xaxis_title="Confidence Score",
+            yaxis_title="Frequency",
+            height=400
         )
         
         return fig
     
     @staticmethod
-    def create_sentiment_gauge(result: Dict, theme: str = 'default') -> go.Figure:
-        """Create an animated sentiment gauge"""
-        colors = config.THEMES.get(theme, config.THEMES['default'])
+    def create_history_dashboard(history: List[Dict]) -> go.Figure:
+        """Create comprehensive history dashboard"""
+        if len(history) < 2:
+            return go.Figure()
         
-        try:
-            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
-            
-        except Exception as e:
-            logger.error(f"Failed to create gauge: {e}")
-            # 返回错误图表
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"Visualization Error: {str(e)}", 
-                x=0.5, y=0.5,
-                xref="paper", yref="paper",
-                showarrow=False,
-                font=dict(size=14)
-            )
-            fig.update_layout(height=400)
-            return fig
-    
-    @staticmethod
-    def create_probability_bars(result: Dict, theme: str = 'default') -> go.Figure:
-        """Create probability bar chart"""
-        colors = config.THEMES.get(theme, config.THEMES['default'])
+        # 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"}]]
+        )
         
-        try:
-            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])
-            ])
-            
-            fig.update_traces(texttemplate='%{text}', textposition='outside')
-            fig.update_layout(
-                title="Sentiment Probabilities",
-                yaxis_title="Probability",
-                height=400,
-                showlegend=False
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Failed to create bars: {e}")
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"Visualization Error: {str(e)}", 
-                x=0.5, y=0.5,
-                xref="paper", yref="paper",
-                showarrow=False
-            )
-            fig.update_layout(height=400)
-            return fig
-
-    @staticmethod
-    def create_batch_summary(results: List[Dict], theme: str = 'default') -> go.Figure:
-        """Create batch analysis summary"""
-        colors = config.THEMES.get(theme, config.THEMES['default'])
+        # Extract data
+        indices = list(range(len(history)))
+        pos_probs = [item['pos_prob'] 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]
         
-        try:
-            # Count sentiments
-            sentiments = [r['sentiment'] for r in results if 'sentiment' in r and r['sentiment'] != 'Error']
-            if not sentiments:
-                fig = go.Figure()
-                fig.add_annotation(text="No valid results to display", x=0.5, y=0.5,
-                                 xref="paper", yref="paper", showarrow=False)
-                fig.update_layout(height=400, title="Batch Summary")
-                return fig
-            
-            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
-            
-        except Exception as e:
-            logger.error(f"Failed to create batch summary: {e}")
-            fig = go.Figure()
-            fig.add_annotation(text=f"Error: {str(e)}", x=0.5, y=0.5,
-                             xref="paper", yref="paper", showarrow=False)
-            fig.update_layout(height=400)
-            return fig
-
-    @staticmethod
-    def create_confidence_distribution(results: List[Dict]) -> go.Figure:
-        """Create confidence distribution plot"""
-        try:
-            confidences = [r['confidence'] for r in results 
-                          if 'confidence' in r and r['sentiment'] != 'Error']
-            
-            if not confidences:
-                fig = go.Figure()
-                fig.add_annotation(text="No confidence data to display", x=0.5, y=0.5,
-                                 xref="paper", yref="paper", showarrow=False)
-                fig.update_layout(height=400, title="Confidence Distribution")
-                return fig
-            
-            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
-            
-        except Exception as e:
-            logger.error(f"Failed to create confidence distribution: {e}")
-            fig = go.Figure()
-            fig.add_annotation(text=f"Error: {str(e)}", x=0.5, y=0.5,
-                             xref="paper", yref="paper", showarrow=False)
-            fig.update_layout(height=400)
-            return fig
+        # Sentiment timeline
+        colors = ['#4CAF50' if s == 'Positive' else '#F44336' 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)
+        fig.add_trace(
+            go.Bar(x=list(sent_counts.keys()), y=list(sent_counts.values()),
+                   marker_color=['#4CAF50' if k == 'Positive' else '#F44336' for k in sent_counts.keys()]),
+            row=2, col=2
+        )
+        
+        fig.update_layout(height=800, showlegend=False)
+        return fig
 
-# Main application functions with better error handling
+# Main application functions
 def analyze_single_text(text: str, language: str, theme: str, clean_text: bool, 
                        remove_punct: bool, remove_nums: bool):
-    """Enhanced single text analysis with error handling"""
+    """Enhanced single text analysis"""
     try:
         if not text.strip():
-            return "❌ Please enter text to analyze", None, None
-        
-        # 初始化检查
-        if not initialize_models():
-            return "❌ Failed to load sentiment analysis models. Please check your internet connection and try again.", None, None
+            return "Please enter text", None, None
         
         # Map display names back to language codes
         language_map = {
@@ -878,7 +540,6 @@ def analyze_single_text(text: str, language: str, theme: str, clean_text: bool,
             'remove_numbers': remove_nums
         }
         
-        # 分析文本
         result = SentimentAnalyzer.analyze_text(text, language_code, preprocessing_options)
         
         # Add to history
@@ -897,49 +558,39 @@ def analyze_single_text(text: str, language: str, theme: str, clean_text: bool,
         history_manager.add_entry(history_entry)
         
         # Create visualizations
-        gauge_fig = AdvancedVisualizer.create_sentiment_gauge(result, theme)
-        bars_fig = AdvancedVisualizer.create_probability_bars(result, theme)
+        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
+        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
         
         # Create info text
         info_text = f"""
-✅ **Analysis Results:**
-- **Sentiment:** {result['sentiment']} (Confidence: {result['confidence']:.3f})
+**Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
 - **Language:** {result['language'].upper()}
-- **Keywords:** {', '.join(result['keywords']) if result['keywords'] else 'None'}
-- **Text Stats:** {result['word_count']} words, {result['char_count']} characters
-
-📊 **Probability Scores:**
-- Positive: {result['pos_prob']:.3f}
-- Negative: {result['neg_prob']:.3f}
-- Neutral: {result.get('neu_prob', 0):.3f}
+- **Keywords:** {', '.join(result['keywords'])}
+- **Stats:** {result['word_count']} words, {result['char_count']} characters
         """
         
         return info_text, gauge_fig, bars_fig
         
     except Exception as e:
-        logger.error(f"Single text analysis failed: {e}")
-        error_msg = f"❌ **Analysis Failed:** {str(e)}\n\nPlease check your input and try again."
-        return error_msg, None, None
+        logger.error(f"Analysis failed: {e}")
+        return f"Error: {str(e)}", None, None
 
 def analyze_batch_texts(batch_text: str, language: str, theme: str, 
                        clean_text: bool, remove_punct: bool, remove_nums: bool):
-    """Batch text analysis with improved error handling"""
+    """Batch text analysis"""
     try:
         if not batch_text.strip():
-            return "❌ Please enter texts to analyze (one per line)", None, None, None
-        
-        # 初始化检查
-        if not initialize_models():
-            return "❌ Failed to load sentiment analysis models", None, None, None
+            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
+            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
+            return "No valid texts found", None, None, None
         
         # Map display names back to language codes
         language_map = {
@@ -984,8 +635,8 @@ def analyze_batch_texts(batch_text: str, language: str, theme: str,
         history_manager.add_batch_entries(batch_entries)
         
         # Create visualizations
-        summary_fig = AdvancedVisualizer.create_batch_summary(results, theme)
-        confidence_fig = AdvancedVisualizer.create_confidence_distribution(results)
+        summary_fig = PlotlyVisualizer.create_batch_summary(results, theme)
+        confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
         
         # Create results table
         df_data = []
@@ -995,9 +646,9 @@ def analyze_batch_texts(batch_text: str, language: str, theme: str,
                     'Index': i+1,
                     'Text': text[:50] + '...' if len(text) > 50 else text,
                     'Sentiment': 'Error',
-                    'Confidence': '0.000',
+                    'Confidence': 0.0,
                     'Language': 'Unknown',
-                    'Error': result.get('error', 'Unknown error')
+                    'Error': result['error']
                 })
             else:
                 df_data.append({
@@ -1006,7 +657,7 @@ def analyze_batch_texts(batch_text: str, language: str, theme: str,
                     'Sentiment': result['sentiment'],
                     'Confidence': f"{result['confidence']:.3f}",
                     'Language': result['language'].upper(),
-                    'Keywords': ', '.join(result.get('keywords', [])[:3])
+                    'Keywords': ', '.join(result['keywords'][:3])
                 })
         
         df = pd.DataFrame(df_data)
@@ -1020,235 +671,214 @@ def analyze_batch_texts(batch_text: str, language: str, theme: str,
             avg_confidence = np.mean([r['confidence'] for r in successful_results])
             
             summary_text = f"""
-✅ **Batch Analysis Summary:**
+**Batch Analysis Summary:**
 - **Total Texts:** {len(texts)}
 - **Successful:** {len(successful_results)}
 - **Errors:** {error_count}
 - **Average Confidence:** {avg_confidence:.3f}
-- **Sentiment Distribution:** 
-  - Positive: {sentiment_counts.get('Positive', 0)}
-  - Negative: {sentiment_counts.get('Negative', 0)}
-  - Neutral: {sentiment_counts.get('Neutral', 0)}
+- **Sentiments:** {dict(sentiment_counts)}
             """
         else:
-            summary_text = f"❌ All {len(texts)} texts failed to analyze."
+            summary_text = f"All {len(texts)} texts failed to analyze."
         
         return summary_text, df, summary_fig, confidence_fig
         
     except Exception as e:
         logger.error(f"Batch analysis failed: {e}")
-        return f"❌ Error: {str(e)}", None, None, None
-
-def get_history_stats():
+        return f"Error: {str(e)}", None, None, None
 
-💡 **Understanding the Results:**
-- **LIME** shows which words push the sentiment positive/negative
-- **Attention** shows which tokens the model focuses on most
-- Higher confidence scores indicate more certain predictions
+def analyze_advanced_text(text: str, language: str, theme: str, include_keywords: bool,
+                         keyword_count: int, min_confidence: float):
+    """Advanced analysis with additional features"""
+    try:
+        if not text.strip():
+            return "Please enter text", None, None
+        
+        # Map display names back to language codes
+        language_map = {
+            'Auto Detect': 'auto',
+            'English': 'en',
+            'Chinese': 'zh',
+            'Spanish': 'es',
+            'French': 'fr',
+            'German': 'de',
+            'Swedish': 'sv'
+        }
+        language_code = language_map.get(language, 'auto')
+        
+        result = SentimentAnalyzer.analyze_text(text, language_code)
+        
+        # Advanced keyword extraction
+        if include_keywords:
+            result['keywords'] = TextProcessor.extract_keywords(text, keyword_count)
+        
+        # Confidence filtering
+        meets_confidence = result['confidence'] >= min_confidence
+        
+        # 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['pos_prob'],
+            'neg_prob': result['neg_prob'],
+            'neu_prob': result.get('neu_prob', 0),
+            'language': result['language'],
+            'timestamp': datetime.now().isoformat(),
+            'analysis_type': 'advanced',
+            'meets_confidence_threshold': meets_confidence
+        }
+        history_manager.add_entry(history_entry)
+        
+        # Create visualizations
+        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
+        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
+        
+        # Create detailed info text
+        confidence_status = "✅ High Confidence" if meets_confidence else "⚠️ Low Confidence"
+        
+        info_text = f"""
+**Advanced Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+- **Confidence Status:** {confidence_status}
+- **Language:** {result['language'].upper()}
+- **Text Statistics:**
+  - Words: {result['word_count']}
+  - Characters: {result['char_count']}
+  - Average word length: {result['char_count']/max(result['word_count'], 1):.1f}
         """
         
-        return info_text, gauge_fig, bars_fig, lime_plot, attention_plot
+        if include_keywords:
+            info_text += f"\n- **Top Keywords:** {', '.join(result['keywords'])}"
+        
+        if not meets_confidence:
+            info_text += f"\n\n⚠️ **Note:** Confidence ({result['confidence']:.3f}) is below threshold ({min_confidence})"
+        
+        return info_text, gauge_fig, bars_fig
         
     except Exception as e:
         logger.error(f"Advanced analysis failed: {e}")
-        # Return basic empty plots on complete failure
-        empty_fig = go.Figure()
-        empty_fig.add_annotation(text=f"Analysis failed: {str(e)}", x=0.5, y=0.5,
-                               xref="paper", yref="paper", showarrow=False)
-        empty_fig.update_layout(height=400)
-        
-        return f"❌ Error: {str(e)}", empty_fig, empty_fig, empty_fig, empty_fig
+        return f"Error: {str(e)}", None, None
+
+def get_history_stats():
     """Get enhanced history statistics"""
-    try:
-        stats = history_manager.get_stats()
-        if not stats:
-            return "📊 No analysis history available yet. Analyze some texts to see statistics!"
-        
-        return f"""
-📊 **Comprehensive History Statistics:**
+    stats = history_manager.get_stats()
+    if not stats:
+        return "No analysis history available"
+    
+    return f"""
+**Comprehensive History Statistics:**
 
-**📈 Analysis Counts:**
+**Analysis Counts:**
 - Total Analyses: {stats['total_analyses']}
-- 😊 Positive: {stats['positive_count']}
-- 😞 Negative: {stats['negative_count']}
-- 😐 Neutral: {stats['neutral_count']}
+- Positive: {stats['positive_count']}
+- Negative: {stats['negative_count']}
+- Neutral: {stats['neutral_count']}
 
-**🎯 Confidence Metrics:**
+**Confidence Metrics:**
 - Average Confidence: {stats['avg_confidence']:.3f}
 - Highest Confidence: {stats['max_confidence']:.3f}
 - Lowest Confidence: {stats['min_confidence']:.3f}
 
-**🌍 Language Statistics:**
+**Language Statistics:**
 - Languages Detected: {stats['languages_detected']}
 - Most Common Language: {stats['most_common_language'].upper()}
 
-**📝 Text Statistics:**
+**Text Statistics:**
 - Average Text Length: {stats['avg_text_length']:.1f} characters
-        """
-    except Exception as e:
-        logger.error(f"Failed to get history stats: {e}")
-        return f"❌ Error getting statistics: {str(e)}"
+    """
 
 def filter_history_display(sentiment_filter: str, language_filter: str, min_confidence: float):
     """Display filtered history"""
-    try:
-        # Convert filters
-        sentiment = sentiment_filter if sentiment_filter != "All" else None
-        language = language_filter.lower() if language_filter != "All" else None
-        
-        filtered_history = history_manager.filter_history(
-            sentiment=sentiment,
-            language=language,
-            min_confidence=min_confidence if min_confidence > 0 else None
-        )
-        
-        if not filtered_history:
-            return "🔍 No entries match the filter criteria", None
-        
-        # Create DataFrame for display
-        df_data = []
-        for entry in filtered_history[-20:]:  # Show last 20 entries
-            df_data.append({
-                'Timestamp': entry['timestamp'][:16],  # YYYY-MM-DD HH:MM
-                'Text': entry['text'],
-                'Sentiment': entry['sentiment'],
-                'Confidence': f"{entry['confidence']:.3f}",
-                'Language': entry['language'].upper(),
-                'Type': entry.get('analysis_type', 'single')
-            })
-        
-        df = pd.DataFrame(df_data)
-        
-        summary = f"""
-🔍 **Filtered Results:**
+    # Convert filters
+    sentiment = sentiment_filter if sentiment_filter != "All" else None
+    language = language_filter.lower() if language_filter != "All" else None
+    
+    filtered_history = history_manager.filter_history(
+        sentiment=sentiment,
+        language=language,
+        min_confidence=min_confidence if min_confidence > 0 else None
+    )
+    
+    if not filtered_history:
+        return "No entries match the filter criteria", None
+    
+    # Create DataFrame for display
+    df_data = []
+    for entry in filtered_history[-20:]:  # Show last 20 entries
+        df_data.append({
+            'Timestamp': entry['timestamp'][:16],  # YYYY-MM-DD HH:MM
+            'Text': entry['text'],
+            'Sentiment': entry['sentiment'],
+            'Confidence': f"{entry['confidence']:.3f}",
+            'Language': entry['language'].upper(),
+            'Type': entry.get('analysis_type', 'single')
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    summary = f"""
+**Filtered Results:**
 - Found {len(filtered_history)} entries matching criteria
 - Showing most recent {min(20, len(filtered_history))} entries
-        """
-        
-        return summary, df
-        
-    except Exception as e:
-        logger.error(f"Failed to filter history: {e}")
-        return f"❌ Error filtering history: {str(e)}", None
+    """
+    
+    return summary, df
 
 def plot_history_dashboard():
-    """Create history dashboard with error handling"""
-    try:
-        history = history_manager.get_history()
-        if len(history) < 2:
-            return None, "📊 Need at least 2 analyses to create dashboard. Analyze more texts!"
-        
-        # 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 = ['#4CAF50' if s == 'Positive' else '#F44336' if s == 'Negative' else '#FF9800' 
-                 for s in sentiments]
-        fig.add_trace(
-            go.Scatter(x=indices, y=pos_probs, mode='lines+markers', 
-                      marker=dict(color=colors, size=6),
-                      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)
-        colors_dict = {'Positive': '#4CAF50', 'Negative': '#F44336', 'Neutral': '#FF9800'}
-        fig.add_trace(
-            go.Bar(x=list(sent_counts.keys()), y=list(sent_counts.values()),
-                   marker_color=[colors_dict.get(k, '#999999') for k in sent_counts.keys()]),
-            row=2, col=2
-        )
-        
-        fig.update_layout(height=800, showlegend=False, title_text="Analysis Dashboard")
-        return fig, f"📊 Dashboard showing {len(history)} analyses"
-        
-    except Exception as e:
-        logger.error(f"Failed to create dashboard: {e}")
-        return None, f"❌ Error creating dashboard: {str(e)}"
+    """Create history dashboard"""
+    history = history_manager.get_history()
+    if len(history) < 2:
+        return None, "Need at least 2 analyses for dashboard"
+    
+    fig = PlotlyVisualizer.create_history_dashboard(history)
+    return fig, f"Dashboard showing {len(history)} analyses"
 
 def export_history_csv():
     """Export history to CSV"""
+    history = history_manager.get_history()
+    if not history:
+        return None, "No history to export"
+    
     try:
-        history = history_manager.get_history()
-        if not history:
-            return None, "📊 No history to export"
-        
         df = pd.DataFrame(history)
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', mode='w')
         df.to_csv(temp_file.name, index=False)
-        return temp_file.name, f"✅ Exported {len(history)} entries to CSV"
+        return temp_file.name, f"Exported {len(history)} entries to CSV"
     except Exception as e:
-        logger.error(f"CSV export failed: {e}")
-        return None, f"❌ Export failed: {str(e)}"
+        return None, f"Export failed: {str(e)}"
 
 def export_history_excel():
     """Export history to Excel"""
+    history = history_manager.get_history()
+    if not history:
+        return None, "No history to export"
+    
     try:
-        history = history_manager.get_history()
-        if not history:
-            return None, "📊 No history to export"
-        
         df = pd.DataFrame(history)
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
         df.to_excel(temp_file.name, index=False)
-        return temp_file.name, f"✅ Exported {len(history)} entries to Excel"
+        return temp_file.name, f"Exported {len(history)} entries to Excel"
     except Exception as e:
-        logger.error(f"Excel export failed: {e}")
-        return None, f"❌ Export failed: {str(e)}"
+        return None, f"Export failed: {str(e)}"
 
 def clear_all_history():
     """Clear analysis history"""
-    try:
-        count = history_manager.clear()
-        return f"🗑️ Cleared {count} entries from history"
-    except Exception as e:
-        logger.error(f"Failed to clear history: {e}")
-        return f"❌ Error clearing history: {str(e)}"
+    count = history_manager.clear()
+    return f"Cleared {count} entries from history"
 
 def get_recent_analyses():
     """Get recent analysis summary"""
-    try:
-        recent = history_manager.get_recent_history(10)
-        if not recent:
-            return "📊 No recent analyses available. Start analyzing some texts!"
-        
-        summary_text = "🕒 **Recent Analyses (Last 10):**\n\n"
-        for i, entry in enumerate(recent, 1):
-            emoji = "😊" if entry['sentiment'] == 'Positive' else "😞" if entry['sentiment'] == 'Negative' else "😐"
-            summary_text += f"{i}. {emoji} **{entry['sentiment']}** ({entry['confidence']:.3f}) - {entry['text']}\n"
-        
-        return summary_text
-    except Exception as e:
-        logger.error(f"Failed to get recent analyses: {e}")
-        return f"❌ Error getting recent analyses: {str(e)}"
+    recent = history_manager.get_recent_history(10)
+    if not recent:
+        return "No recent analyses available"
+    
+    summary_text = "**Recent Analyses (Last 10):**\n\n"
+    for i, entry in enumerate(recent, 1):
+        summary_text += f"{i}. **{entry['sentiment']}** ({entry['confidence']:.3f}) - {entry['text']}\n"
+    
+    return summary_text
 
 # Sample data
 SAMPLE_TEXTS = [
@@ -1280,10 +910,10 @@ Not sure if I like it or not.
 Amazing quality and fast delivery!
 Could be better, but it's okay."""
 
-# Gradio Interface - 简化版本，专注于核心功能
-with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
-    gr.Markdown("# 🎭 Multilingual Sentiment Analyzer")
-    gr.Markdown("Comprehensive sentiment analysis with batch processing and multilingual support")
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment Analyzer") as demo:
+    gr.Markdown("# 🎭 Advanced Multilingual Sentiment Analyzer")
+    gr.Markdown("Comprehensive sentiment analysis with batch processing, advanced analytics, and multilingual support")
     
     with gr.Tab("📝 Single Analysis"):
         with gr.Row():
@@ -1320,140 +950,106 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer")
                 )
             
             with gr.Column(scale=1):
-                result_info = gr.Markdown("Enter text and click Analyze to see results")
+                result_info = gr.Markdown("Enter text and click Analyze")
         
         with gr.Row():
             gauge_plot = gr.Plot(label="Sentiment Gauge")
             bars_plot = gr.Plot(label="Probability Distribution")
-
-    with gr.Tab("🔬 Advanced Analysis"):
+    
+    with gr.Tab("📊 Batch Analysis"):
         with gr.Row():
             with gr.Column(scale=2):
-                advanced_input = gr.Textbox(
-                    label="Text for Advanced Analysis",
-                    placeholder="Enter text for explainability analysis...",
-                    lines=4
+                batch_input = gr.Textbox(
+                    label="Batch Text Input (One text per line)",
+                    placeholder="Enter multiple texts, one per line...",
+                    lines=8
                 )
                 
                 with gr.Row():
-                    advanced_language = gr.Dropdown(
+                    batch_language = gr.Dropdown(
                         choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
                         value='Auto Detect',
                         label="Language"
                     )
-                    advanced_theme = gr.Dropdown(
+                    batch_theme = gr.Dropdown(
                         choices=list(config.THEMES.keys()),
                         value='default',
                         label="Theme"
                     )
                 
-                gr.Markdown("### 🔍 Explainability Options")
-                gr.Markdown("**LIME** shows which words influence sentiment most. **Attention** shows which tokens the model focuses on.")
-                
                 with gr.Row():
-                    use_lime = gr.Checkbox(
-                        label="🔍 Use LIME Analysis", 
-                        value=True,
-                        info="Explains feature importance (requires: pip install lime)"
-                    )
-                    use_attention = gr.Checkbox(
-                        label="👁️ Use Attention Weights", 
-                        value=True,
-                        info="Shows token-level attention patterns"
-                    )
-                
-                lime_features = gr.Slider(
-                    minimum=5,
-                    maximum=20,
-                    value=10,
-                    step=1,
-                    label="LIME Features Count",
-                    info="Number of top features to analyze"
-                )
+                    batch_clean = gr.Checkbox(label="Clean Text", value=False)
+                    batch_remove_punct = gr.Checkbox(label="Remove Punctuation", value=True)
+                    batch_remove_nums = gr.Checkbox(label="Remove Numbers", value=False)
                 
-                advanced_analyze_btn = gr.Button("🔬 Advanced Analyze", variant="primary", size="lg")
+                batch_analyze_btn = gr.Button("🔍 Analyze Batch", variant="primary", size="lg")
                 
                 gr.Examples(
-                    examples=[
-                        ["This movie is absolutely fantastic! The acting is superb and the plot is engaging."],
-                        ["I'm not sure how I feel about this product. It has some good features but also some issues."],
-                        ["The service was terrible and the staff was very rude. I will never come back here again."]
-                    ],
-                    inputs=advanced_input,
-                    label="Sample Texts for Advanced Analysis"
+                    examples=[[BATCH_SAMPLE]],
+                    inputs=batch_input,
+                    label="Sample Batch Input"
                 )
             
             with gr.Column(scale=1):
-                advanced_result_info = gr.Markdown("""
-**Advanced Analysis Features:**
-
-🔍 **LIME (Local Interpretable Model-agnostic Explanations)**
-- Shows which words contribute most to the sentiment prediction
-- Red bars = pushes toward negative sentiment  
-- Green bars = pushes toward positive sentiment
-
-👁️ **Attention Weights**
-- Visualizes which tokens the model pays attention to
-- Darker/higher bars = more attention from the model
-- Helps understand model focus patterns
-
-Configure explainability settings and click **Advanced Analyze** to start.
-                """)
+                batch_summary = gr.Markdown("Enter texts and click Analyze Batch")
         
         with gr.Row():
-            advanced_gauge_plot = gr.Plot(label="Sentiment Gauge")
-            advanced_bars_plot = gr.Plot(label="Probability Distribution")
+            batch_results_table = gr.DataFrame(
+                label="Detailed Results",
+                interactive=False
+            )
         
         with gr.Row():
-            lime_plot = gr.Plot(label="🔍 LIME Feature Importance")
-            attention_plot = gr.Plot(label="👁️ Attention Weights")
-
-    with gr.Tab("📊 Batch Analysis"):
+            batch_summary_plot = gr.Plot(label="Sentiment Summary")
+            batch_confidence_plot = gr.Plot(label="Confidence Distribution")
+    
+    with gr.Tab("🔬 Advanced Analysis"):
         with gr.Row():
             with gr.Column(scale=2):
-                batch_input = gr.Textbox(
-                    label="Batch Text Input (One text per line)",
-                    placeholder="Enter multiple texts, one per line...",
-                    lines=8
+                advanced_input = gr.Textbox(
+                    label="Text for Advanced Analysis",
+                    placeholder="Enter text for detailed analysis...",
+                    lines=4
                 )
                 
                 with gr.Row():
-                    batch_language = gr.Dropdown(
+                    advanced_language = gr.Dropdown(
                         choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
                         value='Auto Detect',
                         label="Language"
                     )
-                    batch_theme = gr.Dropdown(
+                    advanced_theme = gr.Dropdown(
                         choices=list(config.THEMES.keys()),
                         value='default',
                         label="Theme"
                     )
                 
                 with gr.Row():
-                    batch_clean = gr.Checkbox(label="Clean Text", value=False)
-                    batch_remove_punct = gr.Checkbox(label="Remove Punctuation", value=True)
-                    batch_remove_nums = gr.Checkbox(label="Remove Numbers", value=False)
-                
-                batch_analyze_btn = gr.Button("🔍 Analyze Batch", variant="primary", size="lg")
+                    include_keywords = gr.Checkbox(label="Extract Keywords", value=True)
+                    keyword_count = gr.Slider(
+                        minimum=3,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Number of Keywords"
+                    )
                 
-                gr.Examples(
-                    examples=[[BATCH_SAMPLE]],
-                    inputs=batch_input,
-                    label="Sample Batch Input"
+                min_confidence_slider = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Minimum Confidence Threshold"
                 )
+                
+                advanced_analyze_btn = gr.Button("🔬 Advanced Analyze", variant="primary", size="lg")
             
             with gr.Column(scale=1):
-                batch_summary = gr.Markdown("Enter texts and click Analyze Batch to see results")
+                advanced_result_info = gr.Markdown("Configure settings and click Advanced Analyze")
         
         with gr.Row():
-            batch_results_table = gr.DataFrame(
-                label="Detailed Results",
-                interactive=False
-            )
-        
-        with gr.Row():
-            batch_summary_plot = gr.Plot(label="Sentiment Summary")
-            batch_confidence_plot = gr.Plot(label="Confidence Distribution")
+            advanced_gauge_plot = gr.Plot(label="Sentiment Gauge")
+            advanced_bars_plot = gr.Plot(label="Probability Distribution")
     
     with gr.Tab("📈 History & Analytics"):
         with gr.Row():
@@ -1514,13 +1110,6 @@ Configure explainability settings and click **Advanced Analyze** to start.
         outputs=[result_info, gauge_plot, bars_plot]
     )
     
-    # Advanced Analysis
-    advanced_analyze_btn.click(
-        analyze_advanced_text,
-        inputs=[advanced_input, advanced_language, advanced_theme, use_lime, use_attention, lime_features],
-        outputs=[advanced_result_info, advanced_gauge_plot, advanced_bars_plot, lime_plot, attention_plot]
-    )
-    
     # Batch Analysis
     batch_analyze_btn.click(
         analyze_batch_texts,
@@ -1528,6 +1117,13 @@ Configure explainability settings and click **Advanced Analyze** to start.
         outputs=[batch_summary, batch_results_table, batch_summary_plot, batch_confidence_plot]
     )
     
+    # Advanced Analysis
+    advanced_analyze_btn.click(
+        analyze_advanced_text,
+        inputs=[advanced_input, advanced_language, advanced_theme, include_keywords, keyword_count, min_confidence_slider],
+        outputs=[advanced_result_info, advanced_gauge_plot, advanced_bars_plot]
+    )
+    
     # History & Analytics
     stats_btn.click(
         get_history_stats,
@@ -1565,17 +1161,5 @@ Configure explainability settings and click **Advanced Analyze** to start.
         outputs=history_status
     )
 
-# 启动应用
 if __name__ == "__main__":
-    try:
-        logger.info("Starting Multilingual Sentiment Analyzer...")
-        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}")
-        print(f"❌ Application failed to start: {e}")
-        print("Please check your dependencies and try again.")
+    demo.launch(share=True)