Update app.py

app.py

@@ -5,7 +5,6 @@ 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
@@ -17,12 +16,40 @@ 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
 
-# Try to import SHAP and LIME, fall back to basic analysis if not available
+# 设置日志 - 提前初始化
+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
@@ -56,10 +83,13 @@ 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"
+        'zh': "uer/roberta-base-finetuned-dianping-chinese",
+        # 备用模型
+        'fallback': "distilbert-base-uncased-finetuned-sst-2-english"
     }
     
     # Color themes
@@ -72,62 +102,80 @@ 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"""
+    """Manages multiple language models with better error handling"""
     def __init__(self):
         self.models = {}
         self.tokenizers = {}
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self._load_default_model()
+        self.device = self._get_device()
+        self.model_loaded = False
+        self._load_models()
+    
+    def _get_device(self):
+        """安全的设备选择"""
+        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_default_model(self):
-        """Load the default models"""
+    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}")
             
-            # 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}")
+            logger.info(f"Successfully loaded default model: {model_name}")
+            self.model_loaded = True
             
         except Exception as e:
-            logger.error(f"Failed to load models: {e}")
-            raise
+            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")
     
     def get_model(self, language='en'):
         """Get model for specific language"""
-        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
+        if not self.model_loaded:
+            raise RuntimeError("No models are loaded")
+        
+        # 简化：所有语言都使用默认模型
+        return self.models['default'], self.tokenizers['default']
     
     @staticmethod
     def detect_language(text: str) -> str:
-        """Detect text language properly"""
+        """Detect text language with fallback"""
+        if not LANGDETECT_AVAILABLE:
+            # 简单的语言检测
+            if re.search(r'[\u4e00-\u9fff]', text):
+                return 'zh'
+            else:
+                return 'en'
+        
         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'
@@ -137,10 +185,23 @@ class ModelManager:
         except:
             return 'en'
 
-model_manager = ModelManager()
+# 全局模型管理器
+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
 
 class HistoryManager:
-    """Enhanced history manager with more features"""
+    """Enhanced history manager"""
     def __init__(self):
         self._history = []
     
@@ -150,7 +211,6 @@ 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)
     
@@ -158,12 +218,10 @@ 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:
@@ -193,12 +251,12 @@ class HistoryManager:
             '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),
+            '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,
             '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])
+            'avg_text_length': np.mean([len(item.get('full_text', '')) for item in self._history]) if self._history else 0
         }
 
 history_manager = HistoryManager()
@@ -225,14 +283,12 @@ 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)
@@ -245,7 +301,7 @@ class TextProcessor:
         return [line.strip() for line in lines if line.strip()]
 
 class SentimentAnalyzer:
-    """Enhanced sentiment analysis"""
+    """Enhanced sentiment analysis with better error handling"""
     
     @staticmethod
     def analyze_text(text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
@@ -253,6 +309,10 @@ 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)
@@ -260,9 +320,13 @@ class SentimentAnalyzer:
             detected_lang = language
         
         # Get appropriate model
-        model, tokenizer = model_manager.get_model(detected_lang)
+        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}")
         
-        # Preprocessing options - don't clean Chinese text
+        # Preprocessing
         options = preprocessing_options or {}
         processed_text = text
         if options.get('clean_text', False) and not re.search(r'[\u4e00-\u9fff]', text):
@@ -274,8 +338,13 @@ 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)
@@ -322,7 +391,7 @@ class SentimentAnalyzer:
             
         except Exception as e:
             logger.error(f"Analysis failed: {e}")
-            raise
+            raise RuntimeError(f"Sentiment analysis failed: {e}")
 
     @staticmethod
     def analyze_batch(texts: List[str], language: str = 'auto', 
@@ -335,435 +404,213 @@ 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
+                    'text': text[:50] + '...' if len(text) > 50 else text
                 })
         return results
 
-class ExplainabilityAnalyzer:
-    """SHAP and LIME explainability analysis with fallbacks"""
-    
-    @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
+class AdvancedVisualizer:
+    """Enhanced visualizations with Plotly - 修复了类名"""
     
     @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'}
+    def create_sentiment_gauge(result: Dict, theme: str = 'default') -> go.Figure:
+        """Create an animated sentiment gauge"""
+        colors = config.THEMES.get(theme, config.THEMES['default'])
         
         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']
+            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:
-                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
-            }
-            
-        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
-            # This is a fallback when model doesn't support attention output
-            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])))
+                # 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"}
+                        ]
+                    }
+                ))
             
-            return {
-                'method': 'Attention',
-                'tokens': [t[0] for t in attention_weights],
-                'attention_weights': attention_weights
-            }
+            fig.update_layout(height=400, font={'size': 16})
+            return fig
             
         except Exception as e:
-            logger.error(f"Attention analysis failed: {e}")
-            return {'method': 'Attention', 'error': str(e)}
-
-class AdvancedVisualizer:
-    """Visualizations for explainability analysis"""
-    
-    @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, showarrow=False)
-            return fig
-        
-        features, scores = zip(*lime_result['feature_importance'])
-        colors = ['red' if score < 0 else 'green' for score in scores]
-        
-        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'
-            )
-        ])
-        
-        fig.update_layout(
-            title="LIME Feature Importance",
-            xaxis_title="Importance Score",
-            yaxis_title="Features",
-            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:
+            logger.error(f"Failed to create gauge: {e}")
+            # 返回错误图表
             fig = go.Figure()
             fig.add_annotation(
-                text=f"Attention Error: {attention_result['error']}", 
-                x=0.5, y=0.5, 
+                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, title="Attention Analysis Error")
+            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'])
         
-        if not attention_result.get('attention_weights'):
+        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="No attention weights available", 
+                text=f"Visualization Error: {str(e)}", 
                 x=0.5, y=0.5,
-                xref="paper", yref="paper", 
+                xref="paper", yref="paper",
                 showarrow=False
             )
-            fig.update_layout(height=400, title="No Attention Data")
+            fig.update_layout(height=400)
             return fig
-        
-        tokens, weights = zip(*attention_result['attention_weights'])
-        
-        # 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
-        
-        # 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]
-        
-        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>Weight: %{y:.3f}<extra></extra>'
-            )
-        ])
-        
-        fig.update_layout(
-            title="Attention Weights (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)
-        )
-        
-        return fig
-    """Enhanced visualizations with Plotly"""
-    
-    @staticmethod
-    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"}
-                    ]
-                }
-            ))
-        
-        fig.update_layout(height=400, font={'size': 16})
-        return fig
-    
-    @staticmethod
-    def create_probability_bars(result: Dict, theme: str = 'default') -> go.Figure:
-        """Create probability bar chart"""
-        colors = config.THEMES[theme]
-        
-        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(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
 
     @staticmethod
     def create_batch_summary(results: List[Dict], theme: str = 'default') -> go.Figure:
         """Create batch analysis summary"""
-        colors = config.THEMES[theme]
-        
-        # Count sentiments
-        sentiments = [r['sentiment'] for r in results if 'sentiment' in r]
-        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
-        )
+        colors = config.THEMES.get(theme, config.THEMES['default'])
         
-        return fig
+        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"""
-        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
-    
-    @staticmethod
-    def create_history_dashboard(history: List[Dict]) -> 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['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]
-        
-        # 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
+        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
 
-# Main application functions
+# Main application functions with better error handling
 def analyze_single_text(text: str, language: str, theme: str, clean_text: bool, 
                        remove_punct: bool, remove_nums: bool):
-    """Enhanced single text analysis"""
+    """Enhanced single text analysis with error handling"""
     try:
         if not text.strip():
-            return "Please enter text", None, None
+            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
         
         # Map display names back to language codes
         language_map = {
@@ -783,6 +630,7 @@ 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
@@ -801,39 +649,49 @@ def analyze_single_text(text: str, language: str, theme: str, clean_text: bool,
         history_manager.add_entry(history_entry)
         
         # Create visualizations
-        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
-        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
+        gauge_fig = AdvancedVisualizer.create_sentiment_gauge(result, theme)
+        bars_fig = AdvancedVisualizer.create_probability_bars(result, theme)
         
         # Create info text
         info_text = f"""
-**Analysis Results:**
-- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+✅ **Analysis Results:**
+- **Sentiment:** {result['sentiment']} (Confidence: {result['confidence']:.3f})
 - **Language:** {result['language'].upper()}
-- **Keywords:** {', '.join(result['keywords'])}
-- **Stats:** {result['word_count']} words, {result['char_count']} characters
+- **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}
         """
         
         return info_text, gauge_fig, bars_fig
         
     except Exception as e:
-        logger.error(f"Analysis failed: {e}")
-        return f"Error: {str(e)}", None, None
+        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
 
 def analyze_batch_texts(batch_text: str, language: str, theme: str, 
                        clean_text: bool, remove_punct: bool, remove_nums: bool):
-    """Batch text analysis"""
+    """Batch text analysis with improved error handling"""
     try:
         if not batch_text.strip():
-            return "Please enter texts (one per line)", None, None, None
+            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
         
         # 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 = {
@@ -878,8 +736,8 @@ def analyze_batch_texts(batch_text: str, language: str, theme: str,
         history_manager.add_batch_entries(batch_entries)
         
         # Create visualizations
-        summary_fig = PlotlyVisualizer.create_batch_summary(results, theme)
-        confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
+        summary_fig = AdvancedVisualizer.create_batch_summary(results, theme)
+        confidence_fig = AdvancedVisualizer.create_confidence_distribution(results)
         
         # Create results table
         df_data = []
@@ -889,9 +747,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.0,
+                    'Confidence': '0.000',
                     'Language': 'Unknown',
-                    'Error': result['error']
+                    'Error': result.get('error', 'Unknown error')
                 })
             else:
                 df_data.append({
@@ -900,7 +758,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['keywords'][:3])
+                    'Keywords': ', '.join(result.get('keywords', [])[:3])
                 })
         
         df = pd.DataFrame(df_data)
@@ -914,275 +772,217 @@ 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}
-- **Sentiments:** {dict(sentiment_counts)}
+- **Sentiment Distribution:** 
+  - Positive: {sentiment_counts.get('Positive', 0)}
+  - Negative: {sentiment_counts.get('Negative', 0)}
+  - Neutral: {sentiment_counts.get('Neutral', 0)}
             """
         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 analyze_advanced_text(text: str, language: str, theme: str, use_lime: bool,
-                         use_attention: bool, lime_features: int):
-    """Advanced analysis with SHAP and LIME explainability"""
-    try:
-        if not text.strip():
-            return "Please enter text", None, None, 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')
-        
-        # Basic sentiment analysis first
-        result = SentimentAnalyzer.analyze_text(text, language_code)
-        
-        # Create basic visualizations first
-        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
-        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
-        
-        # Initialize explainability results
-        lime_result = None
-        attention_result = None
-        lime_plot = None
-        attention_plot = None
-        
-        # Get model for explainability analysis
-        try:
-            model, tokenizer = model_manager.get_model(language_code)
-            
-            # LIME Analysis
-            if use_lime:
-                lime_result = ExplainabilityAnalyzer.analyze_with_lime(
-                    text, model, tokenizer, model_manager.device, lime_features
-                )
-                lime_plot = AdvancedVisualizer.create_lime_plot(lime_result, theme)
-            else:
-                # Create empty plot
-                lime_plot = go.Figure()
-                lime_plot.add_annotation(text="LIME analysis disabled", x=0.5, y=0.5, 
-                                       xref="paper", yref="paper", showarrow=False)
-                lime_plot.update_layout(height=400, title="LIME Analysis (Disabled)")
-            
-            # Attention Analysis
-            if use_attention:
-                attention_result = ExplainabilityAnalyzer.analyze_with_attention(
-                    text, model, tokenizer, model_manager.device
-                )
-                attention_plot = AdvancedVisualizer.create_attention_plot(attention_result, theme)
-            else:
-                # Create empty plot
-                attention_plot = go.Figure()
-                attention_plot.add_annotation(text="Attention analysis disabled", x=0.5, y=0.5,
-                                            xref="paper", yref="paper", showarrow=False)
-                attention_plot.update_layout(height=400, title="Attention Analysis (Disabled)")
-                
-        except Exception as e:
-            logger.error(f"Explainability analysis failed: {e}")
-            # Create error plots
-            lime_plot = go.Figure()
-            lime_plot.add_annotation(text=f"Analysis Error: {str(e)}", x=0.5, y=0.5,
-                                   xref="paper", yref="paper", showarrow=False)
-            lime_plot.update_layout(height=400, title="Analysis Error")
-            
-            attention_plot = go.Figure()
-            attention_plot.add_annotation(text=f"Analysis Error: {str(e)}", x=0.5, y=0.5,
-                                        xref="paper", yref="paper", showarrow=False)
-            attention_plot.update_layout(height=400, title="Analysis Error")
-        
-        # 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',
-            'explainability_used': use_lime or use_attention
-        }
-        history_manager.add_entry(history_entry)
-        
-        # Create detailed info text
-        info_text = f"""
-**Advanced Analysis Results:**
-- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
-- **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}
-- **Keywords:** {', '.join(result['keywords'])}
-
-**Explainability Analysis:**
-        """
-        
-        if use_lime:
-            if lime_result and 'error' not in lime_result:
-                info_text += f"\n- **LIME:** ✅ Analyzed top {lime_features} features"
-            else:
-                error_msg = lime_result.get('error', 'Unknown error') if lime_result else 'Not available'
-                info_text += f"\n- **LIME:** ❌ {error_msg}"
-        else:
-            info_text += f"\n- **LIME:** ⏸️ Disabled"
-        
-        if use_attention:
-            if attention_result and 'error' not in attention_result:
-                info_text += f"\n- **Attention:** ✅ Token-level attention weights computed"
-            else:
-                error_msg = attention_result.get('error', 'Unknown error') if attention_result else 'Not available'
-                info_text += f"\n- **Attention:** ❌ {error_msg}"
-        else:
-            info_text += f"\n- **Attention:** ⏸️ Disabled"
-        
-        return info_text, gauge_fig, bars_fig, lime_plot, attention_plot
-        
-    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, None
 
 def get_history_stats():
     """Get enhanced history statistics"""
-    stats = history_manager.get_stats()
-    if not stats:
-        return "No analysis history available"
-    
-    return f"""
-**Comprehensive 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:**
 
-**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"""
-    # 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:**
+    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:**
 - Found {len(filtered_history)} entries matching criteria
 - Showing most recent {min(20, len(filtered_history))} entries
-    """
-    
-    return summary, df
+        """
+        
+        return summary, df
+        
+    except Exception as e:
+        logger.error(f"Failed to filter history: {e}")
+        return f"❌ Error filtering history: {str(e)}", None
 
 def plot_history_dashboard():
-    """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"
+    """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)}"
 
 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:
-        return None, f"Export failed: {str(e)}"
+        logger.error(f"CSV export failed: {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:
-        return None, f"Export failed: {str(e)}"
+        logger.error(f"Excel export failed: {e}")
+        return None, f"❌ Export failed: {str(e)}"
 
 def clear_all_history():
     """Clear analysis history"""
-    count = history_manager.clear()
-    return f"Cleared {count} entries from 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)}"
 
 def get_recent_analyses():
     """Get recent analysis summary"""
-    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
+    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)}"
 
 # Sample data
 SAMPLE_TEXTS = [
@@ -1214,10 +1014,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="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")
+# 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")
     
     with gr.Tab("📝 Single Analysis"):
         with gr.Row():
@@ -1254,58 +1054,11 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment An
                 )
             
             with gr.Column(scale=1):
-                result_info = gr.Markdown("Enter text and click Analyze")
+                result_info = gr.Markdown("Enter text and click Analyze to see results")
         
         with gr.Row():
             gauge_plot = gr.Plot(label="Sentiment Gauge")
             bars_plot = gr.Plot(label="Probability Distribution")
-    
-    with gr.Tab("🔬 Advanced 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
-                )
-                
-                with gr.Row():
-                    advanced_language = gr.Dropdown(
-                        choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
-                        value='Auto Detect',
-                        label="Language"
-                    )
-                    advanced_theme = gr.Dropdown(
-                        choices=list(config.THEMES.keys()),
-                        value='default',
-                        label="Theme"
-                    )
-                
-                gr.Markdown("### 🔍 Explainability Options")
-                with gr.Row():
-                    use_lime = gr.Checkbox(label="Use LIME Analysis", value=True)
-                    use_attention = gr.Checkbox(label="Use Attention Weights", value=True)
-                
-                lime_features = gr.Slider(
-                    minimum=5,
-                    maximum=20,
-                    value=10,
-                    step=1,
-                    label="LIME Features Count"
-                )
-                
-                advanced_analyze_btn = gr.Button("🔬 Advanced Analyze", variant="primary", size="lg")
-            
-            with gr.Column(scale=1):
-                advanced_result_info = gr.Markdown("Configure explainability settings and click Advanced Analyze")
-        
-        with gr.Row():
-            advanced_gauge_plot = gr.Plot(label="Sentiment Gauge")
-            advanced_bars_plot = gr.Plot(label="Probability Distribution")
-        
-        with gr.Row():
-            lime_plot = gr.Plot(label="LIME Feature Importance")
-            attention_plot = gr.Plot(label="Attention Weights")
 
     with gr.Tab("📊 Batch Analysis"):
         with gr.Row():
@@ -1342,7 +1095,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment An
                 )
             
             with gr.Column(scale=1):
-                batch_summary = gr.Markdown("Enter texts and click Analyze Batch")
+                batch_summary = gr.Markdown("Enter texts and click Analyze Batch to see results")
         
         with gr.Row():
             batch_results_table = gr.DataFrame(
@@ -1420,13 +1173,6 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment An
         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, use_lime, use_attention, lime_features],
-        outputs=[advanced_result_info, advanced_gauge_plot, advanced_bars_plot, lime_plot, attention_plot]
-    )
-    
     # History & Analytics
     stats_btn.click(
         get_history_stats,
@@ -1464,5 +1210,17 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment An
         outputs=history_status
     )
 
+# 启动应用
 if __name__ == "__main__":
-    demo.launch(share=True)
+    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.")