Update app.py

app.py

@@ -6,7 +6,7 @@ import plotly.express as px
 from plotly.subplots import make_subplots
 import numpy as np
 from wordcloud import WordCloud
-from collections import Counter, defaultdict
+from collections import Counter, defaultdict, OrderedDict
 import re
 import json
 import csv
@@ -23,6 +23,10 @@ from nltk.corpus import stopwords
 import langdetect
 import pandas as pd
 import gc
+import threading
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import time
 
 # Advanced analysis imports
 import shap
@@ -38,6 +42,7 @@ class Config:
     MIN_WORD_LENGTH: int = 2
     CACHE_SIZE: int = 128
     BATCH_PROCESSING_SIZE: int = 8
+    MODEL_CACHE_SIZE: int = 2  # Maximum models to keep in memory
     
     # Supported languages and models
     SUPPORTED_LANGUAGES = {
@@ -99,6 +104,8 @@ def memory_cleanup():
         yield
     finally:
         gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
 
 class ThemeContext:
     """Theme management context"""
@@ -106,9 +113,50 @@ class ThemeContext:
         self.theme = theme
         self.colors = config.THEMES.get(theme, config.THEMES['default'])
 
-# Enhanced Model Manager with Multi-language Support
+class LRUModelCache:
+    """LRU Cache for models with memory management"""
+    def __init__(self, max_size: int = 2):
+        self.max_size = max_size
+        self.cache = OrderedDict()
+        self.lock = threading.Lock()
+    
+    def get(self, key):
+        with self.lock:
+            if key in self.cache:
+                # Move to end (most recently used)
+                self.cache.move_to_end(key)
+                return self.cache[key]
+            return None
+    
+    def put(self, key, value):
+        with self.lock:
+            if key in self.cache:
+                self.cache.move_to_end(key)
+            else:
+                if len(self.cache) >= self.max_size:
+                    # Remove least recently used
+                    oldest_key = next(iter(self.cache))
+                    old_model, old_tokenizer = self.cache.pop(oldest_key)
+                    # Force cleanup
+                    del old_model, old_tokenizer
+                    gc.collect()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                
+                self.cache[key] = value
+    
+    def clear(self):
+        with self.lock:
+            for model, tokenizer in self.cache.values():
+                del model, tokenizer
+            self.cache.clear()
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+# Enhanced Model Manager with Optimized Memory Management
 class ModelManager:
-    """Multi-language model manager with lazy loading"""
+    """Optimized multi-language model manager with LRU cache and lazy loading"""
     _instance = None
     
     def __new__(cls):
@@ -119,38 +167,64 @@ class ModelManager:
     
     def __init__(self):
         if not self._initialized:
-            self.models = {}
-            self.tokenizers = {}
             self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            self._load_default_models()
+            self.model_cache = LRUModelCache(config.MODEL_CACHE_SIZE)
+            self.loading_lock = threading.Lock()
             self._initialized = True
+            logger.info(f"ModelManager initialized on device: {self.device}")
     
-    def _load_default_models(self):
-        """Load default models"""
+    def _load_model(self, model_name: str, cache_key: str):
+        """Load model with memory optimization"""
         try:
-            # Load multilingual model as default
-            model_name = config.MODELS['multilingual']
-            self.tokenizers['default'] = AutoTokenizer.from_pretrained(model_name)
-            self.models['default'] = AutoModelForSequenceClassification.from_pretrained(model_name)
-            self.models['default'].to(self.device)
-            logger.info(f"Default model loaded: {model_name}")
+            logger.info(f"Loading model: {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}")
+            # Load with memory optimization
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForSequenceClassification.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+            
+            if not torch.cuda.is_available():
+                model.to(self.device)
+            
+            # Set to eval mode to save memory
+            model.eval()
+            
+            # Cache the model
+            self.model_cache.put(cache_key, (model, tokenizer))
+            logger.info(f"Model {model_name} loaded and cached successfully")
+            
+            return model, tokenizer
             
         except Exception as e:
-            logger.error(f"Failed to load models: {e}")
+            logger.error(f"Failed to load model {model_name}: {e}")
             raise
     
     def get_model(self, language='en'):
-        """Get model for specific language"""
+        """Get model for specific language with lazy loading and caching"""
+        # Determine cache key and model name
         if language == 'zh':
-            return self.models['zh'], self.tokenizers['zh']
-        return self.models['default'], self.tokenizers['default']
+            cache_key = 'zh'
+            model_name = config.MODELS['zh']
+        else:
+            cache_key = 'multilingual'
+            model_name = config.MODELS['multilingual']
+        
+        # Try to get from cache first
+        cached_model = self.model_cache.get(cache_key)
+        if cached_model is not None:
+            return cached_model
+        
+        # Load model if not in cache (with thread safety)
+        with self.loading_lock:
+            # Double-check pattern
+            cached_model = self.model_cache.get(cache_key)
+            if cached_model is not None:
+                return cached_model
+            
+            return self._load_model(model_name, cache_key)
     
     @staticmethod
     def detect_language(text: str) -> str:
@@ -192,22 +266,6 @@ class TextProcessor:
         cleaned_words = [w for w in words if w not in STOP_WORDS and len(w) >= config.MIN_WORD_LENGTH]
         return ' '.join(cleaned_words)
     
-    @staticmethod
-    def extract_keywords(text: str, top_k: int = 5) -> List[str]:
-        """Extract keywords with language support"""
-        if re.search(r'[\u4e00-\u9fff]', text):
-            # Chinese text processing
-            words = re.findall(r'[\u4e00-\u9fff]+', text)
-            all_chars = ''.join(words)
-            char_freq = Counter(all_chars)
-            return [char for char, _ in char_freq.most_common(top_k)]
-        else:
-            # Other languages
-            cleaned = TextProcessor.clean_text(text)
-            words = cleaned.split()
-            word_freq = Counter(words)
-            return [word for word, _ in word_freq.most_common(top_k)]
-    
     @staticmethod
     def parse_batch_input(text: str) -> List[str]:
         """Parse batch input from textarea"""
@@ -281,16 +339,17 @@ class HistoryManager:
             'most_common_language': Counter(languages).most_common(1)[0][0] if languages else 'en'
         }
 
-# Core Sentiment Analysis Engine (Modified - removed attention analysis)
+# Core Sentiment Analysis Engine with Performance Optimizations
 class SentimentEngine:
-    """Multi-language sentiment analysis engine"""
+    """Optimized multi-language sentiment analysis engine"""
     
     def __init__(self):
         self.model_manager = ModelManager()
+        self.executor = ThreadPoolExecutor(max_workers=4)
     
-    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'keywords': []})
+    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0})
     def analyze_single(self, text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
-        """Analyze single text with basic features"""
+        """Optimized single text analysis"""
         if not text.strip():
             raise ValueError("Empty text provided")
         
@@ -313,14 +372,19 @@ class SentimentEngine:
                 options.get('remove_numbers', False)
             )
         
-        # Tokenize and analyze
+        # Tokenize and analyze with memory optimization
         inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
                          truncation=True, max_length=config.MAX_TEXT_LENGTH).to(self.model_manager.device)
         
+        # Use no_grad for inference to save memory
         with torch.no_grad():
             outputs = model(**inputs)
             probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
         
+        # Clear GPU cache after inference
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
         # Handle different model outputs
         if len(probs) == 3:  # negative, neutral, positive
             sentiment_idx = np.argmax(probs)
@@ -350,56 +414,77 @@ class SentimentEngine:
                 'has_neutral': False
             }
         
-        # Extract basic keywords
-        keywords = TextProcessor.extract_keywords(text, 10)
-        keyword_tuples = [(word, 0.1) for word in keywords]  # Simple keyword extraction
-        
         # Add metadata
         result.update({
             'language': detected_lang,
-            'keywords': keyword_tuples,
             'word_count': len(text.split()),
             'char_count': len(text)
         })
         
         return result
     
+    def _analyze_text_batch(self, text: str, language: str, preprocessing_options: Dict, index: int) -> Dict:
+        """Single text analysis for batch processing"""
+        try:
+            result = self.analyze_single(text, language, preprocessing_options)
+            result['batch_index'] = index
+            result['text'] = text[:100] + '...' if len(text) > 100 else text
+            result['full_text'] = text
+            return result
+        except Exception as e:
+            return {
+                'sentiment': 'Error',
+                'confidence': 0.0,
+                'error': str(e),
+                'batch_index': index,
+                'text': text[:100] + '...' if len(text) > 100 else text,
+                'full_text': text
+            }
+    
     @handle_errors(default_return=[])
     def analyze_batch(self, texts: List[str], language: str = 'auto', 
                      preprocessing_options: Dict = None, progress_callback=None) -> List[Dict]:
-        """Optimized batch processing"""
+        """Optimized parallel batch processing"""
         if len(texts) > config.BATCH_SIZE_LIMIT:
             texts = texts[:config.BATCH_SIZE_LIMIT]
         
-        results = []
-        batch_size = config.BATCH_PROCESSING_SIZE
-        
-        for i in range(0, len(texts), batch_size):
-            batch = texts[i:i+batch_size]
-            
-            if progress_callback:
-                progress_callback((i + len(batch)) / len(texts))
+        if not texts:
+            return []
+        
+        # Pre-load model to avoid race conditions
+        self.model_manager.get_model(language if language != 'auto' else 'en')
+        
+        # Use ThreadPoolExecutor for parallel processing
+        with ThreadPoolExecutor(max_workers=min(4, len(texts))) as executor:
+            futures = []
+            for i, text in enumerate(texts):
+                future = executor.submit(
+                    self._analyze_text_batch, 
+                    text, language, preprocessing_options, i
+                )
+                futures.append(future)
             
-            for text in batch:
+            results = []
+            for i, future in enumerate(futures):
+                if progress_callback:
+                    progress_callback((i + 1) / len(futures))
+                
                 try:
-                    result = self.analyze_single(text, language, preprocessing_options)
-                    result['batch_index'] = len(results)
-                    result['text'] = text[:100] + '...' if len(text) > 100 else text
-                    result['full_text'] = text
+                    result = future.result(timeout=30)  # 30 second timeout per text
                     results.append(result)
                 except Exception as e:
                     results.append({
                         'sentiment': 'Error',
                         'confidence': 0.0,
-                        'error': str(e),
-                        'batch_index': len(results),
-                        'text': text[:100] + '...' if len(text) > 100 else text,
-                        'full_text': text
+                        'error': f"Timeout or error: {str(e)}",
+                        'batch_index': i,
+                        'text': texts[i][:100] + '...' if len(texts[i]) > 100 else texts[i],
+                        'full_text': texts[i]
                     })
         
         return results
 
-# Advanced Analysis Engine (NEW)
+# Advanced Analysis Engine
 class AdvancedAnalysisEngine:
     """Advanced analysis using SHAP and LIME"""
     
@@ -410,13 +495,13 @@ class AdvancedAnalysisEngine:
         """Create prediction function for LIME/SHAP"""
         def predict_proba(texts):
             results = []
-            for text in texts:
-                inputs = tokenizer(text, return_tensors="pt", padding=True, 
-                                 truncation=True, max_length=config.MAX_TEXT_LENGTH).to(device)
-                with torch.no_grad():
+            with torch.no_grad():
+                for text in texts:
+                    inputs = tokenizer(text, return_tensors="pt", padding=True, 
+                                     truncation=True, max_length=config.MAX_TEXT_LENGTH).to(device)
                     outputs = model(**inputs)
                     probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
-                results.append(probs)
+                    results.append(probs)
             return np.array(results)
         return predict_proba
     
@@ -580,7 +665,7 @@ class AdvancedAnalysisEngine:
             logger.error(f"LIME analysis failed: {e}")
             return f"LIME analysis failed: {str(e)}", None, {}
 
-# Advanced Plotly Visualization System (Updated - removed attention visualization)
+# Optimized Plotly Visualization System
 class PlotlyVisualizer:
     """Enhanced Plotly visualizations"""
     
@@ -662,43 +747,6 @@ class PlotlyVisualizer:
         
         return fig
     
-    @staticmethod
-    @handle_errors(default_return=None)
-    def create_keyword_chart(keywords: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> go.Figure:
-        """Create basic keyword chart"""
-        if not keywords:
-            fig = go.Figure()
-            fig.add_annotation(text="No keywords extracted", 
-                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
-            fig.update_layout(height=400, title="Keywords")
-            return fig
-        
-        words = [word for word, score in keywords]
-        scores = [score for word, score in keywords]
-        
-        color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
-        
-        fig = go.Figure(data=[
-            go.Bar(
-                y=words,
-                x=scores,
-                orientation='h',
-                marker_color=color,
-                text=[f'{score:.3f}' for score in scores],
-                textposition='auto'
-            )
-        ])
-        
-        fig.update_layout(
-            title=f"Top Keywords ({sentiment})",
-            xaxis_title="Frequency Score",
-            yaxis_title="Keywords",
-            height=400,
-            showlegend=False
-        )
-        
-        return fig
-    
     @staticmethod
     @handle_errors(default_return=None)
     def create_batch_summary(results: List[Dict], theme: ThemeContext) -> go.Figure:
@@ -827,9 +875,8 @@ class DataHandler:
         if format_type == 'csv':
             writer = csv.writer(temp_file)
             writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Language', 
-                           'Pos_Prob', 'Neg_Prob', 'Neu_Prob', 'Keywords', 'Word_Count'])
+                           'Pos_Prob', 'Neg_Prob', 'Neu_Prob', 'Word_Count'])
             for entry in data:
-                keywords_str = "|".join([f"{word}:{score:.3f}" for word, score in entry.get('keywords', [])])
                 writer.writerow([
                     entry.get('timestamp', ''),
                     entry.get('text', ''),
@@ -839,7 +886,6 @@ class DataHandler:
                     f"{entry.get('pos_prob', 0):.4f}",
                     f"{entry.get('neg_prob', 0):.4f}",
                     f"{entry.get('neu_prob', 0):.4f}",
-                    keywords_str,
                     entry.get('word_count', 0)
                 ])
         elif format_type == 'json':
@@ -881,13 +927,13 @@ class DataHandler:
         
         return content
 
-# Main Application Class
+# Main Application Class - Optimized
 class SentimentApp:
-    """Main multilingual sentiment analysis application"""
+    """Optimized multilingual sentiment analysis application"""
     
     def __init__(self):
         self.engine = SentimentEngine()
-        self.advanced_engine = AdvancedAnalysisEngine()  # NEW
+        self.advanced_engine = AdvancedAnalysisEngine()
         self.history = HistoryManager()
         self.data_handler = DataHandler()
         
@@ -900,12 +946,12 @@ class SentimentApp:
             ["Ce film était magnifique, j'ai adoré la réalisation."],  # French
         ]
     
-    @handle_errors(default_return=("Please enter text", None, None, None))
+    @handle_errors(default_return=("Please enter text", None, None))
     def analyze_single(self, text: str, language: str, theme: str, clean_text: bool, 
                        remove_punct: bool, remove_nums: bool):
-        """Single text analysis with basic visualizations (removed attention analysis)"""
+        """Optimized single text analysis without keyword extraction"""
         if not text.strip():
-            return "Please enter text", None, None, None
+            return "Please enter text", None, None
         
         # Map display names to language codes
         language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
@@ -920,7 +966,7 @@ class SentimentApp:
         with memory_cleanup():
             result = self.engine.analyze_single(text, language_code, preprocessing_options)
             
-            # Add to history
+            # Add to history (without keywords)
             history_entry = {
                 'text': text[:100] + '...' if len(text) > 100 else text,
                 'full_text': text,
@@ -930,35 +976,31 @@ class SentimentApp:
                 'neg_prob': result.get('neg_prob', 0),
                 'neu_prob': result.get('neu_prob', 0),
                 'language': result['language'],
-                'keywords': result['keywords'],
                 'word_count': result['word_count'],
                 'analysis_type': 'single'
             }
             self.history.add(history_entry)
             
-            # Create visualizations
+            # Create visualizations (only gauge and probability bars)
             theme_ctx = ThemeContext(theme)
             gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme_ctx)
             bars_fig = PlotlyVisualizer.create_probability_bars(result, theme_ctx)
-            keyword_fig = PlotlyVisualizer.create_keyword_chart(result['keywords'], result['sentiment'], theme_ctx)
             
             # Create comprehensive result text
-            keywords_str = ", ".join([f"{word}({score:.3f})" for word, score in result['keywords'][:5]])
-            
             info_text = f"""
 **Analysis Results:**
 - **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
 - **Language:** {result['language'].upper()}
-- **Keywords:** {keywords_str}
 - **Statistics:** {result['word_count']} words, {result['char_count']} characters
+- **Probabilities:** Positive: {result.get('pos_prob', 0):.3f}, Negative: {result.get('neg_prob', 0):.3f}, Neutral: {result.get('neu_prob', 0):.3f}
             """
             
-            return info_text, gauge_fig, bars_fig, keyword_fig
+            return info_text, gauge_fig, bars_fig
     
     @handle_errors(default_return=("Please enter texts", None, None, None))
     def analyze_batch(self, batch_text: str, language: str, theme: str, 
                      clean_text: bool, remove_punct: bool, remove_nums: bool):
-        """Enhanced batch analysis"""
+        """Enhanced batch analysis with parallel processing"""
         if not batch_text.strip():
             return "Please enter texts (one per line)", None, None, None
         
@@ -997,7 +1039,6 @@ class SentimentApp:
                         'neg_prob': result.get('neg_prob', 0),
                         'neu_prob': result.get('neu_prob', 0),
                         'language': result['language'],
-                        'keywords': result['keywords'],
                         'word_count': result['word_count'],
                         'analysis_type': 'batch',
                         'batch_index': result['batch_index']
@@ -1024,14 +1065,13 @@ class SentimentApp:
                         'Error': result['error']
                     })
                 else:
-                    keywords_str = ', '.join([word for word, _ in result['keywords'][:3]])
                     df_data.append({
                         'Index': result['batch_index'] + 1,
                         'Text': result['text'],
                         'Sentiment': result['sentiment'],
                         'Confidence': f"{result['confidence']:.3f}",
                         'Language': result['language'].upper(),
-                        'Keywords': keywords_str
+                        'Word_Count': result.get('word_count', 0)
                     })
             
             df = pd.DataFrame(df_data)
@@ -1059,7 +1099,7 @@ class SentimentApp:
             
             return summary_text, df, summary_fig, confidence_fig
     
-    # NEW: Advanced analysis methods
+    # Advanced analysis methods
     @handle_errors(default_return=("Please enter text", None))
     def analyze_with_shap(self, text: str, language: str):
         """Perform SHAP analysis"""
@@ -1120,9 +1160,9 @@ class SentimentApp:
 - **Languages Detected:** {stats['languages_detected']}
         """
 
-# Gradio Interface (Updated with Advanced Analysis tab)
+# Optimized Gradio Interface
 def create_interface():
-    """Create comprehensive Gradio interface with Advanced Analysis tab"""
+    """Create comprehensive Gradio interface with optimizations"""
     app = SentimentApp()
     
     with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
@@ -1169,11 +1209,8 @@ def create_interface():
             with gr.Row():
                 gauge_plot = gr.Plot(label="Sentiment Gauge")
                 probability_plot = gr.Plot(label="Probability Distribution")
-            
-            with gr.Row():
-                keyword_plot = gr.Plot(label="Basic Keywords")
         
-        # NEW: Advanced Analysis Tab
+        # Advanced Analysis Tab
         with gr.Tab("Advanced Analysis"):
             gr.Markdown("## 🔬 Explainable AI Analysis")
             gr.Markdown("Use SHAP and LIME to understand which words and phrases most influence the sentiment prediction.")
@@ -1246,8 +1283,8 @@ def create_interface():
                     batch_summary = gr.Textbox(label="Batch Summary", lines=8)
                     batch_results_df = gr.Dataframe(
                         label="Detailed Results",
-                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Keywords"],
-                        datatype=["number", "str", "str", "str", "str", "str"]
+                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Word_Count"],
+                        datatype=["number", "str", "str", "str", "str", "number"]
                     )
             
             with gr.Row():
@@ -1281,17 +1318,17 @@ def create_interface():
                 csv_download = gr.File(label="CSV Download", visible=True)
                 json_download = gr.File(label="JSON Download", visible=True)
         
-        # Event Handlers
+        # Event Handlers - Updated for optimized single analysis
         
-        # Single Analysis
+        # Single Analysis (removed keyword_plot output)
         analyze_btn.click(
             app.analyze_single,
             inputs=[text_input, language_selector, theme_selector, 
                    clean_text_cb, remove_punct_cb, remove_nums_cb],
-            outputs=[result_output, gauge_plot, probability_plot, keyword_plot]
+            outputs=[result_output, gauge_plot, probability_plot]
         )
         
-        # Advanced Analysis (NEW)
+        # Advanced Analysis
         shap_btn.click(
             app.analyze_with_shap,
             inputs=[advanced_text_input, advanced_language],